home *** CD-ROM | disk | FTP | other *** search
/ Aminet 4 / Aminet 4 - November 1994.iso / aminet / comm / term / term41source.lha / Extras / Source / term-Source.lha / termARexxCommands.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-26  |  96.9 KB  |  5,806 lines
  1. /*
  2. **    termARexxCommands.c
  3. **
  4. **    ARexx interface command support routines
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termARexxGlobal.h"
  11.  
  12.     /* Number of bytes already processed by ScanNodeFilter(). */
  13.  
  14. STATIC LONG WaitCount = 0;
  15.  
  16.     /* Cheapo shortcuts ;-) */
  17.  
  18. #define Args    Pkt -> Array
  19. #define Results    Pkt -> Results
  20.  
  21.     /* ScanNodeFilter():
  22.      *
  23.      *    Scan memory for a certain sequence.
  24.      */
  25.  
  26. STATIC STRPTR __regargs
  27. ScanNodeFilter(register STRPTR Data,register LONG Size,register struct WaitNode *Node,LONG *Position)
  28. {
  29.     register UBYTE c,Mask;
  30.  
  31.     *Position = 0;
  32.  
  33.     if(Config -> SerialConfig -> StripBit8)
  34.         Mask = 0x7F;
  35.     else
  36.         Mask = 0xFF;
  37.  
  38.     if(Node)
  39.     {
  40.         do
  41.         {
  42.             (*Position)++;
  43.  
  44.             if(c = ToUpper((*Data++) & Mask))
  45.             {
  46.                 register BYTE MatchMade;
  47.  
  48.                 do
  49.                 {
  50.                     MatchMade = FALSE;
  51.  
  52.                     if(Node -> Count == WaitCount)
  53.                     {
  54.                         if(c == Node -> Node . ln_Name[WaitCount] & Mask)
  55.                         {
  56.                             MatchMade = TRUE;
  57.  
  58.                             if(!Node -> Node . ln_Name[++Node -> Count])
  59.                             {
  60.                                 if(Node -> ResponseLen)
  61.                                 {
  62.                                     SerWriteVerbatim(Node -> Response,Node -> ResponseLen,FALSE);
  63.  
  64.                                     Node -> Count = 0;
  65.                                 }
  66.                                 else
  67.                                     return(Node -> Node . ln_Name);
  68.                             }
  69.                         }
  70.                     }
  71.  
  72.                     if(MatchMade)
  73.                         WaitCount++;
  74.                     else
  75.                     {
  76.                         if(WaitCount)
  77.                         {
  78.                             WaitCount = 0;
  79.  
  80.                             Node -> Count = 0;
  81.                         }
  82.                         else
  83.                             break;
  84.                     }
  85.                 }
  86.                 while(!WaitCount);
  87.             }
  88.         }
  89.         while(--Size);
  90.     }
  91.     else
  92.     {
  93.         do
  94.         {
  95.             (*Position)++;
  96.  
  97.             if(c = ToUpper((*Data++) & Mask))
  98.             {
  99.                 register BYTE MatchMade;
  100.  
  101.                 do
  102.                 {
  103.                     MatchMade = FALSE;
  104.  
  105.                     Node = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  106.  
  107.                     while(Node -> Node . ln_Succ)
  108.                     {
  109.                         if(Node -> Count == WaitCount)
  110.                         {
  111.                             if(c == Node -> Node . ln_Name[WaitCount] & Mask)
  112.                             {
  113.                                 Node -> Count++;
  114.  
  115.                                 MatchMade = TRUE;
  116.  
  117.                                 if(!Node -> Node . ln_Name[Node -> Count])
  118.                                 {
  119.                                     if(Node -> ResponseLen)
  120.                                     {
  121.                                         SerWriteVerbatim(Node -> Response,Node -> ResponseLen,FALSE);
  122.  
  123.                                         Node -> Count = 0;
  124.                                     }
  125.                                     else
  126.                                         return(Node -> Node . ln_Name);
  127.                                 }
  128.                             }
  129.                         }
  130.  
  131.                         Node = (struct WaitNode *)Node -> Node . ln_Succ;
  132.                     }
  133.  
  134.                     if(MatchMade)
  135.                         WaitCount++;
  136.                     else
  137.                     {
  138.                         if(WaitCount)
  139.                         {
  140.                             WaitCount = 0;
  141.  
  142.                             Node = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  143.  
  144.                             while(Node -> Node . ln_Succ)
  145.                             {
  146.                                 Node -> Count = 0;
  147.  
  148.                                 Node = (struct WaitNode *)Node -> Node . ln_Succ;
  149.                             }
  150.                         }
  151.                         else
  152.                             break;
  153.                     }
  154.                 }
  155.                 while(!WaitCount);
  156.             }
  157.         }
  158.         while(--Size);
  159.     }
  160.  
  161.     return(NULL);
  162. }
  163.  
  164. STRPTR
  165. RexxActivate(struct RexxPkt *Pkt)
  166. {
  167.     if(Window)
  168.         BumpWindow(Window);
  169.     else
  170.         Signal(ThisProcess,SIGBREAKF_CTRL_F);
  171.  
  172.     return(NULL);
  173. }
  174.  
  175. STRPTR
  176. RexxAdd(struct RexxPkt *Pkt)
  177. {
  178.     enum    {    ARG_ADD_FROM,ARG_ADD_BEFORE,ARG_ADD_AFTER,ARG_ADD_RESPONSE,
  179.             ARG_ADD_COMMAND,ARG_ADD_PHONEENTRY,ARG_ADD_NAME };
  180.  
  181.     WORD ListIndex;
  182.  
  183.     if((ListIndex = ToList(Args[ARG_ADD_FROM])) != -1)
  184.     {
  185.         struct GenericList    *List = GenericListTable[ListIndex];
  186.         BYTE             AddMode;
  187.  
  188.         if(Args[ARG_ADD_BEFORE])
  189.             AddMode = ADD_GLIST_BEFORE;
  190.         else
  191.         {
  192.             if(Args[ARG_ADD_AFTER])
  193.                 AddMode = ADD_GLIST_BEHIND;
  194.             else
  195.                 AddMode = ADD_GLIST_BOTTOM;
  196.         }
  197.  
  198.         if(ListIndex == GLIST_DIAL)
  199.         {
  200.             if(Args[ARG_ADD_PHONEENTRY])
  201.             {
  202.                 if(!IsNumeric(Args[ARG_ADD_PHONEENTRY]))
  203.                 {
  204.                     STRPTR Buffer;
  205.  
  206.                     if(Buffer = CreateMatchBuffer(Args[ARG_ADD_PHONEENTRY]))
  207.                     {
  208.                         struct DialNode    *Node;
  209.                         LONG         i;
  210.                         BOOL         GotIt = FALSE;
  211.  
  212.                         for(i = 0 ; i < NumPhoneEntries ; i++)
  213.                         {
  214.                             if(MatchBuffer(Buffer,Phonebook[i] -> Header -> Name))
  215.                             {
  216.                                 if(Node = (struct DialNode *)CreateGenericListNode(sizeof(struct DialNode),""))
  217.                                 {
  218.                                     Node -> Entry = Phonebook[i];
  219.  
  220.                                     AddGenericListNode(List,(struct Node *)Node,AddMode);
  221.  
  222.                                     GotIt = TRUE;
  223.                                 }
  224.                                 else
  225.                                 {
  226.                                     Results[0] = RC_ERROR;
  227.                                     Results[1] = ERROR_NO_FREE_STORE;
  228.  
  229.                                     break;
  230.                                 }
  231.                             }
  232.                         }
  233.  
  234.                         if(!GotIt && Results[0] != RC_ERROR)
  235.                         {
  236.                             Results[0] = RC_ERROR;
  237.                             Results[1] = ERROR_OBJECT_NOT_FOUND;
  238.                         }
  239.  
  240.                         DeleteMatchBuffer(Buffer);
  241.                     }
  242.                     else
  243.                     {
  244.                         Results[0] = RC_ERROR;
  245.                         Results[1] = ERROR_NO_FREE_STORE;
  246.                     }
  247.                 }
  248.                 else
  249.                 {
  250.                     LONG Index = Atol(Args[ARG_ADD_PHONEENTRY]);
  251.  
  252.                     if(Index < 0 || Index > NumPhoneEntries)
  253.                     {
  254.                         Results[0] = RC_ERROR;
  255.                         Results[1] = TERMERROR_INDEX_OUT_OF_RANGE;
  256.                     }
  257.                     else
  258.                     {
  259.                         struct DialNode    *Node;
  260.  
  261.                         if(Node = (struct DialNode *)CreateGenericListNode(sizeof(struct DialNode),""))
  262.                         {
  263.                             Node -> Entry = Phonebook[Index];
  264.  
  265.                             AddGenericListNode(List,(struct Node *)Node,AddMode);
  266.                         }
  267.                         else
  268.                         {
  269.                             Results[0] = RC_ERROR;
  270.                             Results[1] = ERROR_NO_FREE_STORE;
  271.                         }
  272.                     }
  273.                 }
  274.             }
  275.             else
  276.             {
  277.                 if(Args[ARG_ADD_NAME])
  278.                 {
  279.                     struct Node *Node;
  280.  
  281.                     if(Node = CreateGenericListNode(sizeof(struct DialNode),Args[ARG_ADD_NAME]))
  282.                         AddGenericListNode(List,Node,AddMode);
  283.                     else
  284.                     {
  285.                         Results[0] = RC_ERROR;
  286.                         Results[1] = ERROR_NO_FREE_STORE;
  287.                     }
  288.                 }
  289.             }
  290.         }
  291.         else
  292.         {
  293.             if(ListIndex == GLIST_WAIT)
  294.             {
  295.                 STRPTR    Response;
  296.                 LONG    ResponseLen;
  297.  
  298.                 if(Args[ARG_ADD_RESPONSE])
  299.                 {
  300.                     Response    = Args[ARG_ADD_RESPONSE];
  301.                     ResponseLen    = strlen(Response);
  302.                 }
  303.                 else
  304.                 {
  305.                     Response    = NULL;
  306.                     ResponseLen    = 0;
  307.                 }
  308.  
  309.                 if(Args[ARG_ADD_NAME])
  310.                 {
  311.                     struct WaitNode *Node;
  312.  
  313.                     if(Node = (struct WaitNode *)CreateGenericListNode(sizeof(struct WaitNode) + ResponseLen + 1,Args[ARG_ADD_NAME]))
  314.                     {
  315.                         WORD i,Len;
  316.  
  317.                         Len = TranslateString(Node -> Node . ln_Name,Node -> Node . ln_Name);
  318.  
  319.                         Node -> Node . ln_Name[Len] = 0;
  320.  
  321.                         for(i = 0 ; i < strlen(Node -> Node . ln_Name) ; i++)
  322.                             Node -> Node . ln_Name[i] = ToUpper(Node -> Node . ln_Name[i]);
  323.  
  324.                         if(Response && ResponseLen)
  325.                         {
  326.                             Node -> Response = &Node -> Node . ln_Name[Len + 1];
  327.  
  328.                             strcpy(Node -> Response,Response);
  329.  
  330.                             Node -> ResponseLen = TranslateString(Node -> Response,Node -> Response);
  331.                         }
  332.                         else
  333.                             Node -> ResponseLen = 0;
  334.  
  335.                         AddGenericListNode(List,Node,AddMode);
  336.                     }
  337.                     else
  338.                     {
  339.                         Results[0] = RC_ERROR;
  340.                         Results[1] = ERROR_NO_FREE_STORE;
  341.                     }
  342.                 }
  343.                 else
  344.                 {
  345.                     Results[0] = RC_ERROR;
  346.                     Results[1] = ERROR_REQUIRED_ARG_MISSING;
  347.                 }
  348.             }
  349.             else
  350.             {
  351.                 if(ListIndex == GLIST_TRAP)
  352.                 {
  353.                     if(!Args[ARG_ADD_NAME] || !Args[ARG_ADD_COMMAND])
  354.                     {
  355.                         struct TrapNode    *Node;
  356.                         UBYTE         LocalBuffer[256];
  357.                         LONG         NameLen;
  358.  
  359.                         if(strlen(Args[ARG_ADD_NAME]) > 255)
  360.                             Args[ARG_ADD_NAME][255] = 0;
  361.  
  362.                         NameLen = TranslateString(Args[ARG_ADD_NAME],LocalBuffer);
  363.  
  364.                         if(Node = (struct TrapNode *)AllocVecPooled(sizeof(struct TrapNode) + strlen(Args[ARG_ADD_NAME]) + 1 + NameLen + strlen(Args[ARG_ADD_COMMAND]) + 1,MEMF_ANY))
  365.                         {
  366.                             STRPTR String = Node -> Node . ln_Name = (STRPTR)(Node + 1);
  367.  
  368.                             strcpy(String,Args[ARG_ADD_NAME]);
  369.  
  370.                             String += strlen(String) + 1;
  371.  
  372.                             Node -> Sequence = String;
  373.  
  374.                             CopyMem(LocalBuffer,String,NameLen);
  375.  
  376.                             String += NameLen;
  377.  
  378.                             Node -> Command = String;
  379.  
  380.                             strcpy(String,Args[ARG_ADD_COMMAND]);
  381.  
  382.                             Node -> SequenceLen = NameLen;
  383.                             Node -> Count = 0;
  384.  
  385.                             AddGenericListNode(List,Node,AddMode);
  386.                         }
  387.                         else
  388.                         {
  389.                             Results[0] = RC_ERROR;
  390.                             Results[1] = ERROR_NO_FREE_STORE;
  391.                         }
  392.                     }
  393.                     else
  394.                     {
  395.                         Results[0] = RC_ERROR;
  396.                         Results[1] = ERROR_REQUIRED_ARG_MISSING;
  397.                     }
  398.                 }
  399.                 else
  400.                 {
  401.                     if(Args[ARG_ADD_NAME])
  402.                     {
  403.                         struct Node *Node;
  404.  
  405.                         if(Node = CreateGenericListNode(sizeof(struct DialNode),Args[ARG_ADD_NAME]))
  406.                             AddGenericListNode(List,Node,AddMode);
  407.                         else
  408.                         {
  409.                             Results[0] = RC_ERROR;
  410.                             Results[1] = ERROR_NO_FREE_STORE;
  411.                         }
  412.                     }
  413.                     else
  414.                     {
  415.                         Results[0] = RC_ERROR;
  416.                         Results[1] = TERMERROR_WRONG_LIST;
  417.                     }
  418.                 }
  419.             }
  420.         }
  421.     }
  422.     else
  423.     {
  424.         Results[0] = RC_ERROR;
  425.         Results[1] = TERMERROR_UNKNOWN_LIST;
  426.     }
  427.  
  428.     return(NULL);
  429. }
  430.  
  431. STRPTR
  432. RexxBaud(struct RexxPkt *Pkt)
  433. {
  434.     enum    {    ARG_BAUD_RATE };
  435.  
  436.     LONG Rate = *(LONG *)Args[ARG_BAUD_RATE],Min = MILLION,Diff,Index;
  437.     WORD i;
  438.  
  439.     for(i = 0 ; i < NumBaudRates ; i++)
  440.     {
  441.         Diff = Rate - BaudRates[i];
  442.  
  443.         if(Diff >= 0 && Diff < Min)
  444.         {
  445.             Min    = Diff;
  446.             Index    = i;
  447.         }
  448.     }
  449.  
  450.     if(BaudRates[Index] != Config -> SerialConfig -> BaudRate)
  451.     {
  452.         Config -> SerialConfig -> BaudRate = BaudRates[Index];
  453.  
  454.         ConfigChanged = TRUE;
  455.  
  456.         UpdateRequired = TRUE;
  457.     }
  458.  
  459.     return(NULL);
  460. }
  461.  
  462. STRPTR
  463. RexxBeepScreen(struct RexxPkt *Pkt)
  464. {
  465.     BellSignal();
  466.  
  467.     return(NULL);
  468. }
  469.  
  470. STRPTR
  471. RexxCallMenu(struct RexxPkt *Pkt)
  472. {
  473.     enum    {    ARG_CALLMENU_TITLE };
  474.  
  475.     STRPTR Buffer;
  476.  
  477.     if(Buffer = CreateMatchBuffer(Args[ARG_CALLMENU_TITLE]))
  478.     {
  479.         WORD i;
  480.  
  481.         Results[0] = RC_WARN;
  482.  
  483.             /* Scan the menu list... */
  484.  
  485.         for(i = 0 ; TermMenu[i] . nm_Type != NM_END ; i++)
  486.         {
  487.                 /* Did we get a valid name string? */
  488.  
  489.             if(TermMenu[i] . nm_Label != NM_BARLABEL)
  490.             {
  491.                     /* Does the name match our template? */
  492.  
  493.                 if(MatchBuffer(Buffer,TermMenu[i] . nm_Label))
  494.                 {
  495.                     HandleMenuCode((ULONG)TermMenu[i] . nm_UserData,NULL);
  496.  
  497.                     Results[0] = RC_OK;
  498.  
  499.                     break;
  500.                 }
  501.             }
  502.         }
  503.  
  504.         DeleteMatchBuffer(Buffer);
  505.     }
  506.     else
  507.     {
  508.         Results[0] = RC_ERROR;
  509.         Results[1] = ERROR_NO_FREE_STORE;
  510.     }
  511.  
  512.     return(NULL);
  513. }
  514.  
  515. STRPTR
  516. RexxCapture(struct RexxPkt *Pkt)
  517. {
  518.     enum    {    ARG_CAPTURE_TO,ARG_CAPTURE_NAME };
  519.  
  520.     if(!Stricmp(Args[ARG_CAPTURE_TO],"PRINTER"))
  521.     {
  522.         if(!PrinterCapture)
  523.             OpenPrinterCapture(FALSE);
  524.     }
  525.     else
  526.     {
  527.         if(!Stricmp(Args[ARG_CAPTURE_TO],"FILE"))
  528.         {
  529.             if(FileCapture)
  530.             {
  531.                 Results[0] = RC_ERROR;
  532.                 Results[1] = ERROR_OBJECT_IN_USE;
  533.             }
  534.             else
  535.             {
  536.                 if(Args[ARG_CAPTURE_NAME])
  537.                 {
  538.                     if(FileCapture = BufferOpen(Args[ARG_CAPTURE_NAME],"a"))
  539.                         strcpy(CaptureName,Args[ARG_CAPTURE_NAME]);
  540.                     else
  541.                     {
  542.                         Results[0] = RC_ERROR;
  543.                         Results[1] = IoErr();
  544.                     }
  545.                 }
  546.                 else
  547.                 {
  548.                     UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  549.                                 *DummyChar;
  550.                     struct FileRequester    *FileRequest;
  551.  
  552.                     if(!CaptureName[0])
  553.                     {
  554.                         strcpy(CaptureName,Config -> CaptureConfig -> CapturePath);
  555.  
  556.                         if(!AddPart(CaptureName,LocaleString(MSG_DIALPANEL_CAPTURE_NAME_TXT),MAX_FILENAME_LENGTH))
  557.                             CaptureName[0] = 0;
  558.                     }
  559.  
  560.                     strcpy(DummyBuffer,CaptureName);
  561.  
  562.                     DummyChar = PathPart(DummyBuffer);
  563.  
  564.                     *DummyChar = 0;
  565.  
  566.                     BlockWindows();
  567.  
  568.                     if(FileRequest = GetFile(Window,LocaleString(MSG_TERMMAIN_CAPTURE_TO_DISK_TXT),DummyBuffer,FilePart(CaptureName),DummyBuffer,NULL,TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_OPEN_TXT),FALSE))
  569.                     {
  570.                         BYTE Continue;
  571.  
  572.                         if(GetFileSize(DummyBuffer))
  573.                         {
  574.                             Continue = TRUE;
  575.  
  576.                             switch(MyEasyRequest(Window,LocaleString(MSG_GLOBAL_FILE_ALREADY_EXISTS_TXT),LocaleString(MSG_GLOBAL_CREATE_APPEND_CANCEL_TXT),DummyBuffer))
  577.                             {
  578.                                 case 1:
  579.  
  580.                                     FileCapture = BufferOpen(DummyBuffer,"w");
  581.                                     break;
  582.  
  583.                                 case 2:
  584.  
  585.                                     FileCapture = BufferOpen(DummyBuffer,"a");
  586.                                     break;
  587.  
  588.                                 case 0:
  589.  
  590.                                     Results[0] = RC_WARN;
  591.                                     Continue = FALSE;
  592.                                     break;
  593.                             }
  594.                         }
  595.                         else
  596.                         {
  597.                             Continue = TRUE;
  598.  
  599.                             FileCapture = BufferOpen(DummyBuffer,"w");
  600.                         }
  601.  
  602.                         if(Continue)
  603.                         {
  604.                             if(!FileCapture)
  605.                             {
  606.                                 MyEasyRequest(Window,LocaleString(MSG_GLOBAL_ERROR_OPENING_FILE_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),DummyBuffer);
  607.  
  608.                                 Results[0] = RC_ERROR;
  609.                                 Results[1] = IoErr();
  610.                             }
  611.                             else
  612.                             {
  613.                                 strcpy(CaptureName,DummyBuffer);
  614.  
  615.                                 CheckItem(MEN_CAPTURE_TO_FILE,TRUE);
  616.                             }
  617.                         }
  618.  
  619.                         FreeAslRequest(FileRequest);
  620.                     }
  621.  
  622.                     ReleaseWindows();
  623.                 }
  624.             }
  625.         }
  626.         else
  627.         {
  628.             Results[0] = RC_ERROR;
  629.             Results[1] = ERROR_REQUIRED_ARG_MISSING;
  630.         }
  631.     }
  632.  
  633.     ConOutputUpdate();
  634.  
  635.     Forbid();
  636.  
  637.     CheckItem(MEN_CAPTURE_TO_FILE,        FileCapture != NULL);
  638.     CheckItem(MEN_CAPTURE_TO_PRINTER,    PrinterCapture != NULL);
  639.  
  640.     Permit();
  641.  
  642.     return(NULL);
  643. }
  644.  
  645. STRPTR
  646. RexxClear(struct RexxPkt *Pkt)
  647. {
  648.     enum    {    ARG_CLEAR_FROM,ARG_CLEAR_FORCE };
  649.  
  650.     if(!Stricmp(Args[ARG_CLEAR_FROM],"BUFFER"))
  651.     {
  652.         if(Lines)
  653.         {
  654.             if(Args[ARG_CLEAR_FORCE])
  655.             {
  656.                 FreeBuffer();
  657.  
  658.                 TerminateBuffer();
  659.             }
  660.             else
  661.             {
  662.                 BlockWindows();
  663.  
  664.                 if(MyEasyRequest(Window,LocaleString(MSG_TERMMAIN_BUFFER_STILL_HOLDS_LINES_TXT),LocaleString(MSG_GLOBAL_YES_NO_TXT),Lines))
  665.                 {
  666.                     FreeBuffer();
  667.  
  668.                     TerminateBuffer();
  669.                 }
  670.                 else
  671.                     Results[0] = RC_WARN;
  672.  
  673.                 ReleaseWindows();
  674.             }
  675.         }
  676.     }
  677.     else
  678.     {
  679.         WORD ListIndex;
  680.  
  681.         if((ListIndex = ToList(Args[ARG_CLEAR_FROM])) != -1)
  682.             ClearGenericList(GenericListTable[ListIndex]);
  683.         else
  684.         {
  685.             Results[0] = RC_ERROR;
  686.             Results[1] = TERMERROR_UNKNOWN_LIST;
  687.         }
  688.     }
  689.  
  690.     return(NULL);
  691. }
  692.  
  693. STRPTR
  694. RexxClearScreen(struct RexxPkt *Pkt)
  695. {
  696.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  697.         XEmulatorClearConsole(XEM_IO);
  698.     else
  699.     {
  700.         DropMarker();
  701.  
  702.         ConBypass("\033[2J\033[H",-1);
  703.     }
  704.  
  705.     return(NULL);
  706. }
  707.  
  708. STRPTR
  709. RexxClose(struct RexxPkt *Pkt)
  710. {
  711.     enum    {    ARG_CLOSE_FROM };
  712.  
  713.     STATIC STRPTR ValidArgs[3] =
  714.     {
  715.         "PRINTER",
  716.         "FILE",
  717.         "ALL"
  718.     };
  719.  
  720.     WORD i;
  721.  
  722.     for(i = 0 ; i < 3 ; i++)
  723.     {
  724.         if(!Stricmp(Args[ARG_CLOSE_FROM],ValidArgs[i]))
  725.         {
  726.             if(i == 0 || i == 2)
  727.             {
  728.                 if(PrinterCapture)
  729.                     ClosePrinterCapture(TRUE);
  730.             }
  731.  
  732.             if(i == 1 || i == 2)
  733.             {
  734.                 if(FileCapture)
  735.                 {
  736.                     BufferClose(FileCapture);
  737.  
  738.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  739.  
  740.                     FileCapture = NULL;
  741.  
  742.                     if(!GetFileSize(CaptureName))
  743.                         DeleteFile(CaptureName);
  744.                     else
  745.                     {
  746.                         AddProtection(CaptureName,FIBF_EXECUTE);
  747.  
  748.                         if(Config -> MiscConfig -> CreateIcons)
  749.                             AddIcon(CaptureName,FILETYPE_TEXT,TRUE);
  750.                     }
  751.  
  752.                     ConOutputUpdate();
  753.                 }
  754.             }
  755.  
  756.             return(NULL);
  757.         }
  758.     }
  759.  
  760.     Results[0] = RC_ERROR;
  761.     Results[1] = ERROR_TOO_MANY_ARGS;
  762.  
  763.     return(NULL);
  764. }
  765.  
  766. STRPTR
  767. RexxCloseDevice(struct RexxPkt *Pkt)
  768. {
  769.     ClearSerial();
  770.  
  771.     DeleteSerial();
  772.  
  773.     return(NULL);
  774. }
  775.  
  776. STRPTR
  777. RexxCloseRequester(struct RexxPkt *Pkt)
  778. {
  779.     if(ThisProcess)
  780.         Signal(ThisProcess,SIG_BREAK);
  781.     else
  782.         Results[0] = RC_WARN;
  783.  
  784.     return(NULL);
  785. }
  786.  
  787. STRPTR
  788. RexxDeactivate(struct RexxPkt *Pkt)
  789. {
  790.     Forbid();
  791.  
  792.     if(Window)
  793.         DoIconify = TRUE;
  794.  
  795.     Permit();
  796.  
  797.     return(NULL);
  798. }
  799.  
  800. STRPTR
  801. RexxDial(struct RexxPkt *Pkt)
  802. {
  803.     enum    {    ARG_SYNC,ARG_DIAL_NUM };
  804.  
  805.     struct PhoneNode    *DialNode;
  806.     struct GenericList    *List;
  807.  
  808.     if(Args[ARG_DIAL_NUM])
  809.     {
  810.         struct List *LocalList;
  811.  
  812.         if(LocalList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  813.         {
  814.             LONG Len = strlen(Args[ARG_DIAL_NUM]);
  815.  
  816.             NewList(LocalList);
  817.  
  818.             if(DialNode = (struct PhoneNode *)AllocVecPooled(sizeof(struct PhoneNode) + Len + 1,MEMF_ANY | MEMF_CLEAR))
  819.             {
  820.                 DialNode -> VanillaNode . ln_Name = (STRPTR)(DialNode + 1);
  821.  
  822.                 strcpy(DialNode -> VanillaNode . ln_Name,Args[ARG_DIAL_NUM]);
  823.  
  824.                 AddTail(LocalList,&DialNode -> VanillaNode);
  825.  
  826.                 FreeDialList(TRUE);
  827.  
  828.                 DialList = LocalList;
  829.             }
  830.             else
  831.             {
  832.                 FreeVecPooled(LocalList);
  833.  
  834.                 Results[0] = RC_ERROR;
  835.                 Results[1] = ERROR_NO_FREE_STORE;
  836.  
  837.                 return(NULL);
  838.             }
  839.         }
  840.     }
  841.     else
  842.     {
  843.         if(GenericListCount(List = GenericListTable[GLIST_DIAL]))
  844.         {
  845.             struct DialNode *Node = (struct DialNode *)FirstGenericListNode(List);
  846.  
  847.             if(Node)
  848.             {
  849.                 LONG Len;
  850.  
  851.                 if(!DialList)
  852.                 {
  853.                     if(DialList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY | MEMF_CLEAR))
  854.                         NewList(DialList);
  855.                 }
  856.  
  857.                 if(DialList)
  858.                 {
  859.                     while(Node)
  860.                     {
  861.                         if(Node -> Entry)
  862.                             Len = 0;
  863.                         else
  864.                             Len = strlen(Node -> Node . ln_Name) + 1;
  865.  
  866.                         if(DialNode = (struct PhoneNode *)AllocVecPooled(sizeof(struct PhoneNode) + Len,MEMF_ANY | MEMF_CLEAR))
  867.                         {
  868.                             if(Node -> Entry)
  869.                                 DialNode -> Entry = Node -> Entry;
  870.                             else
  871.                             {
  872.                                 DialNode -> VanillaNode . ln_Name = (STRPTR)(DialNode + 1);
  873.  
  874.                                 strcpy(DialNode -> VanillaNode . ln_Name,Node -> Node . ln_Name);
  875.                             }
  876.  
  877.                             AddTail(DialList,&DialNode -> VanillaNode);
  878.                         }
  879.                         else
  880.                         {
  881.                             FreeDialList(FALSE);
  882.  
  883.                             Results[0] = RC_ERROR;
  884.                             Results[1] = ERROR_NO_FREE_STORE;
  885.  
  886.                             return(NULL);
  887.                         }
  888.  
  889.                         Node = (struct DialNode *)NextGenericListNode(List);
  890.                     }
  891.                 }
  892.             }
  893.         }
  894.     }
  895.  
  896.     if(DialList)
  897.     {
  898.         if(DialList -> lh_Head -> ln_Succ)
  899.         {
  900.             DoDial = DIAL_LIST;
  901.  
  902.             Forbid();
  903.  
  904.             if(!DialMsg && Args[ARG_SYNC])
  905.             {
  906.                 DialMsg = Pkt -> RexxMsg;
  907.  
  908.                 Pkt -> RexxMsg = NULL;
  909.             }
  910.  
  911.             Permit();
  912.         }
  913.         else
  914.         {
  915.             FreeDialList(FALSE);
  916.  
  917.             Results[0] = RC_ERROR;
  918.             Results[1] = TERMERROR_LIST_IS_ALREADY_EMPTY;
  919.         }
  920.     }
  921.     else
  922.     {
  923.         Results[0] = RC_ERROR;
  924.         Results[1] = ERROR_NO_FREE_STORE;
  925.     }
  926.  
  927.     return(NULL);
  928. }
  929.  
  930. STRPTR
  931. RexxDelay(struct RexxPkt *Pkt)
  932. {
  933.     enum    {    ARG_DELAY_MICROSECONDS,ARG_DELAY_SECONDS,ARG_DELAY_MINUTES,ARG_DELAY_QUIET };
  934.  
  935.     LONG    Seconds = 0,
  936.         Micros;
  937.     ULONG    Signals;
  938.     BYTE    Quiet;
  939.  
  940.     if(Args[ARG_DELAY_QUIET] || !ReadRequest || !WriteRequest)
  941.         Quiet = TRUE;
  942.     else
  943.         Quiet = FALSE;
  944.  
  945.     if(Args[ARG_DELAY_MINUTES])
  946.         Seconds += 60 * (*(LONG *)Args[ARG_DELAY_MINUTES]);
  947.  
  948.     if(Args[ARG_DELAY_SECONDS])
  949.         Seconds += *(LONG *)Args[ARG_DELAY_SECONDS];
  950.  
  951.     if(Args[ARG_DELAY_MICROSECONDS])
  952.         Micros = *(LONG *)Args[ARG_DELAY_MICROSECONDS];
  953.     else
  954.         Micros = 0;
  955.  
  956.     if(Seconds || Micros)
  957.     {
  958.         StartTime(Seconds,Micros);
  959.  
  960.         BlockWindows();
  961.  
  962.         if(Marking)
  963.             DropMarker();
  964.  
  965.         if(Quiet)
  966.             Signals = NULL;
  967.         else
  968.         {
  969.             if(DataHold)
  970.             {
  971.                 ConProcess(DataHold,DataSize);
  972.  
  973.                 Status = STATUS_READY;
  974.  
  975.                 DataHold = NULL;
  976.  
  977.                 RestartSerial(TRUE);
  978.             }
  979.  
  980.             Signals = CheckSignal(SIG_SERIAL);
  981.         }
  982.  
  983.         FOREVER
  984.         {
  985.             if(Signals & SIG_SERIAL)
  986.             {
  987.                 if(!WaitSerialRead())
  988.                 {
  989.                     LONG Length;
  990.  
  991.                     BytesIn++;
  992.  
  993.                     if(Translate_CR_LF)
  994.                         Length = (* Translate_CR_LF)(ReadBuffer,1);
  995.                     else
  996.                         Length = 1;
  997.  
  998.                     if(Length)
  999.                     {
  1000.                         ConProcess(ReadBuffer,Length);
  1001.  
  1002.                         Status = STATUS_READY;
  1003.                     }
  1004.  
  1005.                         /* Check how many bytes are still in
  1006.                          * the serial buffer.
  1007.                          */
  1008.  
  1009.                     if(Length = GetSerialWaiting())
  1010.                     {
  1011.                         if(Length > SerialBufferSize)
  1012.                             Length = SerialBufferSize;
  1013.  
  1014.                         if(Length > Config -> SerialConfig -> Quantum)
  1015.                             Length = Config -> SerialConfig -> Quantum;
  1016.  
  1017.                         if(!DoSerialRead(ReadBuffer,Length))
  1018.                         {
  1019.                             BytesIn += Length;
  1020.  
  1021.                             if(Translate_CR_LF)
  1022.                                 Length = (* Translate_CR_LF)(ReadBuffer,Length);
  1023.  
  1024.                                 /* Send the data to the console. */
  1025.  
  1026.                             if(Length)
  1027.                                 ConProcess(ReadBuffer,Length);
  1028.  
  1029.                             Status = STATUS_READY;
  1030.                         }
  1031.                     }
  1032.                 }
  1033.  
  1034.                 RestartSerial(TRUE);
  1035.             }
  1036.  
  1037.             if(Signals & SIG_BREAK)
  1038.             {
  1039.                 StopTime();
  1040.  
  1041.                 Results[0] = RC_WARN;
  1042.  
  1043.                 break;
  1044.             }
  1045.  
  1046.             if(Signals & SIG_TIMER)
  1047.             {
  1048.                 WaitIO(TimeRequest);
  1049.  
  1050.                 break;
  1051.             }
  1052.  
  1053.             if(Quiet)
  1054.                 Signals = Wait(SIG_TIMER | SIG_BREAK);
  1055.             else
  1056.                 Signals = Wait(SIG_TIMER | SIG_BREAK | SIG_SERIAL);
  1057.         }
  1058.  
  1059.         ReleaseWindows();
  1060.     }
  1061.  
  1062.     return(NULL);
  1063. }
  1064.  
  1065. STRPTR
  1066. RexxDuplex(struct RexxPkt *Pkt)
  1067. {
  1068.     enum    {    ARG_DUPLEX_FULL,ARG_DUPLEX_HALF };
  1069.  
  1070.     BYTE Mode;
  1071.  
  1072.     if(Args[ARG_DUPLEX_FULL])
  1073.         Mode = DUPLEX_FULL;
  1074.  
  1075.     if(Args[ARG_DUPLEX_HALF])
  1076.         Mode = DUPLEX_HALF;
  1077.  
  1078.     if(Config -> SerialConfig -> Duplex != Mode)
  1079.     {
  1080.         Config -> SerialConfig -> Duplex = Mode;
  1081.  
  1082.         UpdateRequired = TRUE;
  1083.  
  1084.         ConfigChanged = TRUE;
  1085.     }
  1086.  
  1087.     return(NULL);
  1088. }
  1089.  
  1090. STRPTR
  1091. RexxFault(struct RexxPkt *Pkt)
  1092. {
  1093.     enum    {    ARG_FAULT_CODE };
  1094.  
  1095.     LONG    Code = *(LONG *)Args[ARG_FAULT_CODE];
  1096.     UBYTE    RexxResultString[256];
  1097.     STRPTR    Result;
  1098.  
  1099.     if(Code >= ERR10_001 && Code <= ERR10_048)
  1100.         Result = LocaleString(MSG_AREXX_SYSERR10_001_TXT + Code - ERR10_001);
  1101.     else
  1102.     {
  1103.         if(Code >= TERMERROR_NO_DATA_TO_PROCESS && Code <= TERMERROR_WRONG_LIST)
  1104.             Result = LocaleString(MSG_AREXX_HOSTERR_000_TXT + Code - TERMERROR_NO_DATA_TO_PROCESS);
  1105.         else
  1106.         {
  1107.             Fault(Code,"",RexxResultString,256);
  1108.  
  1109.             Result = &RexxResultString[2];
  1110.         }
  1111.     }
  1112.  
  1113.     return(CreateResult(Result,Results));
  1114. }
  1115.  
  1116. STRPTR
  1117. RexxGetClip(struct RexxPkt *Pkt)
  1118. {
  1119.     enum    {    ARG_GETCLIP_UNIT };
  1120.  
  1121.     struct IFFHandle    *Handle;
  1122.     STRPTR             ResultBuffer = NULL;
  1123.  
  1124.     if(Handle = AllocIFF())
  1125.     {
  1126.         if(Args[ARG_GETCLIP_UNIT])
  1127.             Handle -> iff_Stream = (ULONG)OpenClipboard(*(LONG *)Args[ARG_GETCLIP_UNIT]);
  1128.         else
  1129.             Handle -> iff_Stream = (ULONG)OpenClipboard(Config -> ClipConfig -> ClipboardUnit);
  1130.  
  1131.         if(Handle -> iff_Stream)
  1132.         {
  1133.             InitIFFasClip(Handle);
  1134.  
  1135.             if(!OpenIFF(Handle,IFFF_READ))
  1136.             {
  1137.                 if(!StopChunk(Handle,ID_FTXT,ID_CHRS))
  1138.                 {
  1139.                     if(!ParseIFF(Handle,IFFPARSE_SCAN))
  1140.                     {
  1141.                         struct ContextNode *ContextNode;
  1142.  
  1143.                         ContextNode = CurrentChunk(Handle);
  1144.  
  1145.                         if(ContextNode -> cn_Type == ID_FTXT && ContextNode -> cn_Size > 0)
  1146.                         {
  1147.                             STRPTR Result;
  1148.  
  1149.                             if(Result = (STRPTR)AllocVecPooled(ContextNode -> cn_Size,MEMF_ANY))
  1150.                             {
  1151.                                 if(ReadChunkBytes(Handle,Result,ContextNode -> cn_Size) == ContextNode -> cn_Size)
  1152.                                     ResultBuffer = CreateArgstring(Result,ContextNode -> cn_Size);
  1153.  
  1154.                                 FreeVecPooled(Result);
  1155.                             }
  1156.                             else
  1157.                             {
  1158.                                 Results[0] = RC_ERROR;
  1159.                                 Results[1] = ERROR_NO_FREE_STORE;
  1160.                             }
  1161.                         }
  1162.                         else
  1163.                             Results[0] = RC_WARN;
  1164.                     }
  1165.                     else
  1166.                     {
  1167.                         Results[0] = RC_ERROR;
  1168.                         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1169.                     }
  1170.                 }
  1171.                 else
  1172.                 {
  1173.                     Results[0] = RC_ERROR;
  1174.                     Results[1] = ERROR_OBJECT_NOT_FOUND;
  1175.                 }
  1176.  
  1177.                 CloseIFF(Handle);
  1178.             }
  1179.             else
  1180.             {
  1181.                 Results[0] = RC_ERROR;
  1182.                 Results[1] = ERROR_OBJECT_NOT_FOUND;
  1183.             }
  1184.  
  1185.             CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  1186.         }
  1187.         else
  1188.         {
  1189.             Results[0] = RC_ERROR;
  1190.             Results[1] = TERMERROR_UNIT_NOT_AVAILABLE;
  1191.         }
  1192.  
  1193.         FreeIFF(Handle);
  1194.     }
  1195.     else
  1196.     {
  1197.         Results[0] = RC_ERROR;
  1198.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1199.     }
  1200.  
  1201.     return(ResultBuffer);
  1202. }
  1203.  
  1204. STRPTR
  1205. RexxGoOnline(struct RexxPkt *Pkt)
  1206. {
  1207.     if(!Online)
  1208.     {
  1209.         ObtainSemaphore(&OnlineSemaphore);
  1210.  
  1211.         WasOnline        = Online;
  1212.         Online            = TRUE;
  1213.  
  1214.         ReleaseSemaphore(&OnlineSemaphore);
  1215.  
  1216.         BaudCount        = 0;
  1217.         BaudBuffer[0]        = 0;
  1218.         BaudPending        = FALSE;
  1219.         CurrentPay        = 0;
  1220.  
  1221.         ObtainSemaphore(&PatternSemaphore);
  1222.  
  1223.         ChosenEntry        = NULL;
  1224.         ChosenPattern        = NULL;
  1225.  
  1226.         ReleaseSemaphore(&PatternSemaphore);
  1227.  
  1228.         Password[0]        = 0;
  1229.         UserName[0]        = 0;
  1230.         SendStartup        = FALSE;
  1231.         LimitCount        = -1;
  1232.         CurrentBBSName[0]    = 0;
  1233.         CurrentBBSComment[0]    = 0;
  1234.         CurrentBBSNumber[0]    = 0;
  1235.  
  1236.         Forbid();
  1237.  
  1238.         SetDialMenu(FALSE);
  1239.  
  1240.         Permit();
  1241.     }
  1242.  
  1243.     return(NULL);
  1244. }
  1245.  
  1246. STRPTR
  1247. RexxHangup(struct RexxPkt *Pkt)
  1248. {
  1249.     if(!WriteRequest)
  1250.     {
  1251.         Results[0] = RC_WARN;
  1252.  
  1253.         return(NULL);
  1254.     }
  1255.  
  1256.     BlockWindows();
  1257.  
  1258.     HangUp();
  1259.  
  1260.         /* We are no longer online. */
  1261.  
  1262.     ObtainSemaphore(&OnlineSemaphore);
  1263.  
  1264.     WasOnline    = Online;
  1265.     Online        = FALSE;
  1266.  
  1267.     ReleaseSemaphore(&OnlineSemaphore);
  1268.  
  1269.         /* Reset time limit. */
  1270.  
  1271.     LimitCount = -1;
  1272.  
  1273.         /* Clear the password. */
  1274.  
  1275.     Password[0]        = 0;
  1276.     UserName[0]        = 0;
  1277.  
  1278.     CurrentBBSName[0]    = 0;
  1279.     CurrentBBSComment[0]    = 0;
  1280.     CurrentBBSNumber[0]    = 0;
  1281.  
  1282.         /* Note the  last action. */
  1283.  
  1284.     LogAction(LocaleString(MSG_TERMMAIN_LOGMSG_HANG_UP_TXT));
  1285.  
  1286.     ReleaseWindows();
  1287.  
  1288.         /* Execute logoff macro. */
  1289.  
  1290.     if(WasOnline && Config -> CommandConfig -> LogoffMacro[0])
  1291.         SerialCommand(Config -> CommandConfig -> LogoffMacro);
  1292.  
  1293.         /* Update the logfile. */
  1294.  
  1295.     StopCall(FALSE);
  1296.  
  1297.         /* Don't execute the logoff macro twice. */
  1298.  
  1299.     ObtainSemaphore(&OnlineSemaphore);
  1300.  
  1301.     WasOnline = FALSE;
  1302.  
  1303.     ReleaseSemaphore(&OnlineSemaphore);
  1304.  
  1305.         /* Enable the dialing functions. */
  1306.  
  1307.     SetDialMenu(TRUE);
  1308.  
  1309.     if(Config -> ModemConfig -> RedialAfterHangup)
  1310.     {
  1311.         if(DialList)
  1312.         {
  1313.             if(DialList -> lh_Head -> ln_Succ)
  1314.                 DoDial = DIAL_REDIAL;
  1315.         }
  1316.     }
  1317.  
  1318.     ObtainSemaphore(&PatternSemaphore);
  1319.  
  1320.     ChosenEntry    = NULL;
  1321.     ChosenPattern    = NULL;
  1322.  
  1323.     ReleaseSemaphore(&PatternSemaphore);
  1324.  
  1325.     return(NULL);
  1326. }
  1327.  
  1328. STRPTR
  1329. RexxHelp(struct RexxPkt *Pkt)
  1330. {
  1331.     enum    {    ARG_HELP_COMMAND,ARG_HELP_PROMPT };
  1332.  
  1333.     if(Args[ARG_HELP_PROMPT])
  1334.         GuideSetup();
  1335.     else
  1336.     {
  1337.         WORD i;
  1338.  
  1339.         for(i = 0 ; i < CommandTableSize ; i++)
  1340.         {
  1341.             if(!Stricmp(Args[ARG_HELP_COMMAND],CommandTable[i] . Name))
  1342.             {
  1343.                 if(CommandTable[i] . Arguments)
  1344.                     return(CreateResult(CommandTable[i] . Arguments,Results));
  1345.                 else
  1346.                     return(CreateResult(",",Results));
  1347.             }
  1348.         }
  1349.  
  1350.         Results[0] = RC_ERROR;
  1351.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1352.     }
  1353.  
  1354.     return(NULL);
  1355. }
  1356.  
  1357. STRPTR
  1358. RexxOpen(struct RexxPkt *Pkt)
  1359. {
  1360.     enum    {    ARG_OPEN_NAME,ARG_OPEN_TO };
  1361.  
  1362.     WORD Index = ToConfig(Args[ARG_OPEN_TO]);
  1363.  
  1364.     if(Index == -1 || Index > DATATYPE_PHONEBOOK)
  1365.     {
  1366.         Results[0] = RC_ERROR;
  1367.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1368.     }
  1369.     else
  1370.     {
  1371.         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  1372.         STRPTR    FileName;
  1373.  
  1374.         if(Args[ARG_OPEN_NAME])
  1375.             FileName = Args[ARG_OPEN_NAME];
  1376.         else
  1377.         {
  1378.             STRPTR             Title;
  1379.             struct FileRequester    *FileRequest;
  1380.  
  1381.             FileName = NULL;
  1382.  
  1383.             switch(Index)
  1384.             {
  1385.                 case DATATYPE_TRANSLATIONS:
  1386.  
  1387.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_TRANSLATION_TXT);
  1388.                     break;
  1389.  
  1390.                 case DATATYPE_FUNCTIONKEYS:
  1391.  
  1392.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_KEYBOARD_MACROS_TXT);
  1393.                     break;
  1394.  
  1395.                 case DATATYPE_CURSORKEYS:
  1396.  
  1397.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_CURSOR_KEYS_TXT);
  1398.                     break;
  1399.  
  1400.                 case DATATYPE_FASTMACROS:
  1401.  
  1402.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_FAST_MACROS_TXT);
  1403.                     break;
  1404.  
  1405.                 case DATATYPE_HOTKEYS:
  1406.  
  1407.                     Title = LocaleString(MSG_HOTKEYPANEL_LOAD_HOTKEYS_TXT);
  1408.                     break;
  1409.  
  1410.                 case DATATYPE_SPEECH:
  1411.  
  1412.                     Title = LocaleString(MSG_SPEECHPANEL_LOAD_SPEECH_SETTINGS_TXT);
  1413.                     break;
  1414.  
  1415.                 case DATATYPE_SOUND:
  1416.  
  1417.                     Title = LocaleString(MSG_SOUNDPANEL_LOAD_SOUNDS_TXT);
  1418.                     break;
  1419.  
  1420.                 case DATATYPE_BUFFER:
  1421.  
  1422.                     Title = LocaleString(MSG_TERMMAIN_LOAD_BUFFER_TXT);
  1423.                     break;
  1424.  
  1425.                 case DATATYPE_CONFIGURATION:
  1426.  
  1427.                     Title = LocaleString(MSG_TERMMAIN_OPEN_PREFERENCES_TXT);
  1428.                     break;
  1429.  
  1430.                 case DATATYPE_PHONEBOOK:
  1431.  
  1432.                     Title = LocaleString(MSG_PHONEPANEL_LOAD_PHONEBOOK_TXT);
  1433.                     break;
  1434.             }
  1435.  
  1436.             BlockWindows();
  1437.  
  1438.             if(FileRequest = GetFile(Window,Title,"","",DummyBuffer,NULL,FALSE,FALSE,FALSE,"Ok",TRUE))
  1439.             {
  1440.                 FileName = DummyBuffer;
  1441.  
  1442.                 FreeAslRequest(FileRequest);
  1443.             }
  1444.             else
  1445.                 Results[0] = RC_WARN;
  1446.  
  1447.             ReleaseWindows();
  1448.         }
  1449.  
  1450.         if(FileName)
  1451.         {
  1452.             if(!GetFileSize(FileName))
  1453.             {
  1454.                 Results[0] = RC_ERROR;
  1455.                 Results[1] = ERROR_OBJECT_NOT_FOUND;
  1456.  
  1457.                 return(NULL);
  1458.             }
  1459.  
  1460.             BlockWindows();
  1461.  
  1462.             switch(Index)
  1463.             {
  1464.                 case DATATYPE_TRANSLATIONS:
  1465.                 {
  1466.                     struct TranslationEntry    **Send,
  1467.                                 **Receive = NULL;
  1468.                     BYTE            Success = FALSE;
  1469.  
  1470.                     if(Send = AllocTranslationTable())
  1471.                     {
  1472.                         if(Receive = AllocTranslationTable())
  1473.                         {
  1474.                             if(!(Success = LoadTranslationTables(FileName,Send,Receive)))
  1475.                             {
  1476.                                 Results[0] = RC_ERROR;
  1477.                                 Results[1] = IoErr();
  1478.                             }
  1479.                         }
  1480.                         else
  1481.                         {
  1482.                             Results[0] = RC_ERROR;
  1483.                             Results[1] = ERROR_NO_FREE_STORE;
  1484.                         }
  1485.                     }
  1486.                     else
  1487.                     {
  1488.                         Results[0] = RC_ERROR;
  1489.                         Results[1] = ERROR_NO_FREE_STORE;
  1490.                     }
  1491.  
  1492.                     if(!Success)
  1493.                     {
  1494.                         if(Send)
  1495.                             FreeTranslationTable(Send);
  1496.  
  1497.                         if(Receive)
  1498.                             FreeTranslationTable(Receive);
  1499.                     }
  1500.                     else
  1501.                     {
  1502.                         strcpy(Config -> FileConfig -> TranslationFileName,FileName);
  1503.  
  1504.                         strcpy(LastTranslation,FileName);
  1505.  
  1506.                         FreeTranslationTable(SendTable);
  1507.                         FreeTranslationTable(ReceiveTable);
  1508.  
  1509.                         SendTable    = Send;
  1510.                         ReceiveTable    = Receive;
  1511.                     }
  1512.                 }
  1513.  
  1514.                 break;
  1515.  
  1516.                 case DATATYPE_FUNCTIONKEYS:
  1517.                 {
  1518.                     if(!LoadMacros(FileName,MacroKeys))
  1519.                     {
  1520.                         Results[0] = RC_ERROR;
  1521.                         Results[1] = IoErr();
  1522.                     }
  1523.                     else
  1524.                     {
  1525.                         MacroChanged = FALSE;
  1526.  
  1527.                         strcpy(Config -> FileConfig -> MacroFileName,FileName);
  1528.  
  1529.                         strcpy(LastMacros,FileName);
  1530.                     }
  1531.                 }
  1532.  
  1533.                 break;
  1534.  
  1535.                 case DATATYPE_CURSORKEYS:
  1536.                 {
  1537.                     if(!ReadIFFData(FileName,CursorKeys,sizeof(struct CursorKeys),ID_KEYS))
  1538.                     {
  1539.                         Results[0] = RC_ERROR;
  1540.                         Results[1] = IoErr();
  1541.                     }
  1542.                     else
  1543.                     {
  1544.                         CursorKeysChanged = FALSE;
  1545.  
  1546.                         strcpy(Config -> FileConfig -> CursorFileName,FileName);
  1547.  
  1548.                         strcpy(LastCursorKeys,FileName);
  1549.                     }
  1550.                 }
  1551.  
  1552.                 break;
  1553.  
  1554.                 case DATATYPE_FASTMACROS:
  1555.                 {
  1556.                     if(!LoadFastMacros(FileName,&FastMacroList))
  1557.                     {
  1558.                         Results[0] = RC_ERROR;
  1559.                         Results[1] = IoErr();
  1560.                     }
  1561.                     else
  1562.                     {
  1563.                         strcpy(Config -> FileConfig -> FastMacroFileName,FileName);
  1564.  
  1565.                         strcpy(LastFastMacros,FileName);
  1566.  
  1567.                         FastMacrosChanged = FALSE;
  1568.                     }
  1569.  
  1570.                     RefreshFastWindow(TRUE);
  1571.                 }
  1572.  
  1573.                 break;
  1574.  
  1575.                 case DATATYPE_HOTKEYS:
  1576.                 {
  1577.                     if(!LoadHotkeys(FileName,&Hotkeys))
  1578.                     {
  1579.                         Results[0] = RC_ERROR;
  1580.                         Results[1] = IoErr();
  1581.                     }
  1582.                     else
  1583.                     {
  1584.                         strcpy(LastKeys,FileName);
  1585.  
  1586.                         HotkeysChanged = FALSE;
  1587.  
  1588.                         SetupCx();
  1589.                     }
  1590.                 }
  1591.  
  1592.                 break;
  1593.  
  1594.                 case DATATYPE_SPEECH:
  1595.                 {
  1596.                     if(!ReadIFFData(FileName,&SpeechConfig,sizeof(struct SpeechConfig),ID_SPEK))
  1597.                     {
  1598.                         Results[0] = RC_ERROR;
  1599.                         Results[1] = IoErr();
  1600.                     }
  1601.                     else
  1602.                     {
  1603.                         strcpy(LastSpeech,FileName);
  1604.  
  1605.                         SpeechSetup();
  1606.  
  1607.                         SpeechChanged = FALSE;
  1608.                     }
  1609.                 }
  1610.  
  1611.                 break;
  1612.  
  1613.                 case DATATYPE_SOUND:
  1614.                 {
  1615.                     if(!ReadIFFData(FileName,&SoundConfig,sizeof(struct SoundConfig),ID_SOUN))
  1616.                     {
  1617.                         Results[0] = RC_ERROR;
  1618.                         Results[1] = IoErr();
  1619.                     }
  1620.                     else
  1621.                     {
  1622.                         strcpy(LastSound,FileName);
  1623.  
  1624.                         SoundInit();
  1625.  
  1626.                         SoundChanged = FALSE;
  1627.                     }
  1628.                 }
  1629.  
  1630.                 break;
  1631.  
  1632.                 case DATATYPE_BUFFER:
  1633.                 {
  1634.                     BPTR SomeFile;
  1635.  
  1636.                     if(SomeFile = Open(FileName,MODE_OLDFILE))
  1637.                     {
  1638.                         LONG Len;
  1639.  
  1640.                         LineRead(NULL,NULL,NULL);
  1641.  
  1642.                         while((Len = LineRead(SomeFile,FileName,80)) > 0)
  1643.                             StoreBuffer(FileName,Len,AddLine);
  1644.  
  1645.                         Close(SomeFile);
  1646.  
  1647.                         BufferChanged = TRUE;
  1648.                     }
  1649.                     else
  1650.                     {
  1651.                         Results[0] = RC_ERROR;
  1652.                         Results[1] = IoErr();
  1653.                     }
  1654.                 }
  1655.  
  1656.                 break;
  1657.  
  1658.                 case DATATYPE_CONFIGURATION:
  1659.                 {
  1660.                     if(ReadConfig(FileName,PrivateConfig))
  1661.                     {
  1662.                         SwapConfig(PrivateConfig,Config);
  1663.  
  1664.                         strcpy(FileName,LastConfig);
  1665.  
  1666.                         ConfigSetup();
  1667.  
  1668.                         ConfigChanged = FALSE;
  1669.                     }
  1670.                     else
  1671.                     {
  1672.                         Results[0] = RC_ERROR;
  1673.                         Results[1] = IoErr();
  1674.                     }
  1675.                 }
  1676.  
  1677.                 break;
  1678.  
  1679.                 case DATATYPE_PHONEBOOK:
  1680.                 {
  1681.                     if(ChosenEntry)
  1682.                     {
  1683.                         Results[0] = RC_ERROR;
  1684.                         Results[1] = ERROR_OBJECT_IN_USE;
  1685.                     }
  1686.                     else
  1687.                     {
  1688.                         if(!LoadPhonebook(FileName))
  1689.                         {
  1690.                             Results[0] = RC_ERROR;
  1691.                             Results[1] = IoErr();
  1692.                         }
  1693.                         else
  1694.                         {
  1695.                             strcpy(LastPhone,FileName);
  1696.  
  1697.                             PhonebookChanged = FALSE;
  1698.  
  1699.                             RebuildMenu = TRUE;
  1700.                         }
  1701.                     }
  1702.                 }
  1703.  
  1704.                 break;
  1705.             }
  1706.  
  1707.             ReleaseWindows();
  1708.         }
  1709.         else
  1710.             Results[0] = RC_WARN;
  1711.     }
  1712.  
  1713.     return(NULL);
  1714. }
  1715.  
  1716. STRPTR
  1717. RexxOpenDevice(struct RexxPkt *Pkt)
  1718. {
  1719.     enum    {    ARG_OPENDEVICE_NAME,ARG_OPENDEVICE_UNIT };
  1720.  
  1721.     if(ReadRequest)
  1722.     {
  1723.         Results[0] = RC_ERROR;
  1724.         Results[1] = TERMERROR_DEVICE_DRIVER_STILL_OPEN;
  1725.     }
  1726.     else
  1727.     {
  1728.         if(Args[ARG_OPENDEVICE_NAME])
  1729.         {
  1730.             strcpy(Config -> SerialConfig -> SerialDevice,Args[ARG_OPENDEVICE_NAME]);
  1731.  
  1732.             ConfigChanged = TRUE;
  1733.         }
  1734.  
  1735.         if(Args[ARG_OPENDEVICE_UNIT])
  1736.         {
  1737.             Config -> SerialConfig -> UnitNumber = *(LONG *)Args[ARG_OPENDEVICE_UNIT];
  1738.  
  1739.             ConfigChanged = TRUE;
  1740.         }
  1741.  
  1742.         BlockWindows();
  1743.  
  1744.         ReopenSerial();
  1745.  
  1746.         ReleaseWindows();
  1747.     }
  1748.  
  1749.     return(NULL);
  1750. }
  1751.  
  1752. STRPTR
  1753. RexxOpenRequester(struct RexxPkt *Pkt)
  1754. {
  1755.     enum    {    ARG_OPENREQUESTER_REQUESTER };
  1756.  
  1757.     WORD Index;
  1758.  
  1759.     if((Index = ToRequester(Args[ARG_OPENREQUESTER_REQUESTER])) == -1)
  1760.     {
  1761.         Results[0] = RC_ERROR;
  1762.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1763.     }
  1764.     else
  1765.     {
  1766.         ULONG    Code;
  1767.         WORD    i;
  1768.  
  1769.         switch(Index)
  1770.         {
  1771.             case REQUESTER_SERIAL:
  1772.  
  1773.                 Code = MEN_SERIAL;
  1774.                 break;
  1775.  
  1776.             case REQUESTER_MODEM:
  1777.  
  1778.                 Code = MEN_MODEM;
  1779.                 break;
  1780.  
  1781.             case REQUESTER_SCREEN:
  1782.  
  1783.                 Code = MEN_SCREEN;
  1784.                 break;
  1785.  
  1786.             case REQUESTER_TERMINAL:
  1787.  
  1788.                 Code = MEN_TERMINAL;
  1789.                 break;
  1790.  
  1791.             case REQUESTER_EMULATION:
  1792.  
  1793.                 Code = MEN_SET_EMULATION;
  1794.                 break;
  1795.  
  1796.             case REQUESTER_CLIPBOARD:
  1797.  
  1798.                 Code = MEN_CLIPBOARD;
  1799.                 break;
  1800.  
  1801.             case REQUESTER_CAPTURE:
  1802.  
  1803.                 Code = MEN_CAPTURE;
  1804.                 break;
  1805.  
  1806.             case REQUESTER_COMMANDS:
  1807.  
  1808.                 Code = MEN_COMMANDS;
  1809.                 break;
  1810.  
  1811.             case REQUESTER_MISC:
  1812.  
  1813.                 Code = MEN_MISC;
  1814.                 break;
  1815.  
  1816.             case REQUESTER_PATH:
  1817.  
  1818.                 Code = MEN_PATH;
  1819.                 break;
  1820.  
  1821.             case REQUESTER_TRANSFER:
  1822.  
  1823.                 Code = MEN_TRANSFER;
  1824.                 break;
  1825.  
  1826.             case REQUESTER_TRANSLATIONS:
  1827.  
  1828.                 Code = MEN_TRANSLATION;
  1829.                 break;
  1830.  
  1831.             case REQUESTER_FUNCTIONKEYS:
  1832.  
  1833.                 Code = MEN_MACROS;
  1834.                 break;
  1835.  
  1836.             case REQUESTER_CURSORKEYS:
  1837.  
  1838.                 Code = MEN_CURSORKEYS;
  1839.                 break;
  1840.  
  1841.             case REQUESTER_FASTMACROS:
  1842.  
  1843.                 Code = MEN_FAST_MACROS;
  1844.                 break;
  1845.  
  1846.             case REQUESTER_HOTKEYS:
  1847.  
  1848.                 Code = MEN_HOTKEYS;
  1849.                 break;
  1850.  
  1851.             case REQUESTER_SPEECH:
  1852.  
  1853.                 Code = MEN_SPEECH;
  1854.                 break;
  1855.  
  1856.             case REQUESTER_SOUND:
  1857.  
  1858.                 Code = MEN_SOUND;
  1859.                 break;
  1860.  
  1861.  
  1862.             case REQUESTER_PHONE:
  1863.  
  1864.                 Code = MEN_PHONEBOOK;
  1865.                 break;
  1866.         }
  1867.  
  1868.             /* Scan the menu list... */
  1869.  
  1870.         for(i = 0 ; TermMenu[i] . nm_Type != NM_END ; i++)
  1871.         {
  1872.                 /* Did we get a valid name string? */
  1873.  
  1874.             if(TermMenu[i] . nm_Label != NM_BARLABEL)
  1875.             {
  1876.                 if((ULONG)TermMenu[i] . nm_UserData == Code)
  1877.                 {
  1878.                     HandleMenuCode((ULONG)TermMenu[i] . nm_UserData,NULL);
  1879.  
  1880.                     break;
  1881.                 }
  1882.             }
  1883.         }
  1884.     }
  1885.  
  1886.     return(NULL);
  1887. }
  1888.  
  1889. STRPTR
  1890. RexxParity(struct RexxPkt *Pkt)
  1891. {
  1892.     enum    {    ARG_PARITY_EVEN,ARG_PARITY_ODD,ARG_PARITY_NONE,ARG_PARITY_MARK,ARG_PARITY_SPACE };
  1893.  
  1894.     BYTE Mode;
  1895.  
  1896.     if(Args[ARG_PARITY_EVEN])
  1897.         Mode = PARITY_EVEN;
  1898.  
  1899.     if(Args[ARG_PARITY_ODD])
  1900.         Mode = PARITY_ODD;
  1901.  
  1902.     if(Args[ARG_PARITY_NONE])
  1903.         Mode = PARITY_NONE;
  1904.  
  1905.     if(Args[ARG_PARITY_MARK])
  1906.         Mode = PARITY_MARK;
  1907.  
  1908.     if(Args[ARG_PARITY_SPACE])
  1909.         Mode = PARITY_SPACE;
  1910.  
  1911.     if(Config -> SerialConfig -> Parity != Mode)
  1912.     {
  1913.         Config -> SerialConfig -> Parity = Mode;
  1914.  
  1915.         UpdateRequired = TRUE;
  1916.  
  1917.         ConfigChanged = TRUE;
  1918.     }
  1919.  
  1920.     return(NULL);
  1921. }
  1922.  
  1923. STRPTR
  1924. RexxPasteClip(struct RexxPkt *Pkt)
  1925. {
  1926.     enum    {    ARG_PASTECLIP_UNIT };
  1927.  
  1928.     struct DataMsg    *Msg;
  1929.     LONG         Unit;
  1930.  
  1931.     if(Args[ARG_PASTECLIP_UNIT])
  1932.         Unit = *(LONG *)Args[ARG_PASTECLIP_UNIT];
  1933.     else
  1934.         Unit = Config -> ClipConfig -> ClipboardUnit;
  1935.  
  1936.     if(Msg = (struct DataMsg *)CreateMsgItem(sizeof(struct DataMsg)))
  1937.     {
  1938.         Msg -> Type = DATAMSGTYPE_WRITECLIP;
  1939.         Msg -> Size = Unit;
  1940.  
  1941.         PutMsgItem(SpecialQueue,(struct MsgItem *)Msg);
  1942.     }
  1943.     else
  1944.     {
  1945.         Results[0] = RC_ERROR;
  1946.         Results[1] = ERROR_NO_FREE_STORE;
  1947.     }
  1948.  
  1949.     return(NULL);
  1950. }
  1951.  
  1952. STRPTR
  1953. RexxPrint(struct RexxPkt *Pkt)
  1954. {
  1955.     enum    {    ARG_PRINT_FROM,ARG_PRINT_TO,ARG_PRINT_SERIAL,ARG_PRINT_MODEM,ARG_PRINT_SCREEN,
  1956.             ARG_PRINT_TERMINAL,ARG_PRINT_USER,ARG_PRINT_COMMENT,ARG_PRINT_SIZE,
  1957.             ARG_PRINT_DATE,ARG_PRINT_BITS };
  1958.  
  1959.     WORD    Index,Mode = -1;
  1960.     ULONG    Flags = NULL;
  1961.  
  1962.     if(Args[ARG_PRINT_SERIAL])
  1963.         Flags |= PRINT_SERIAL;
  1964.  
  1965.     if(Args[ARG_PRINT_MODEM])
  1966.         Flags |= PRINT_MODEM;
  1967.  
  1968.     if(Args[ARG_PRINT_SCREEN])
  1969.         Flags |= PRINT_SCREEN;
  1970.  
  1971.     if(Args[ARG_PRINT_TERMINAL])
  1972.         Flags |= PRINT_TERMINAL;
  1973.  
  1974.     if(Args[ARG_PRINT_USER])
  1975.         Flags |= PRINT_USERNAME;
  1976.  
  1977.     if(Args[ARG_PRINT_COMMENT])
  1978.         Flags |= PRINT_COMMENT;
  1979.  
  1980.     if(Args[ARG_PRINT_SIZE])
  1981.         Flags |= PRINT_SIZE;
  1982.  
  1983.     if(Args[ARG_PRINT_DATE])
  1984.         Flags |= PRINT_DATE;
  1985.  
  1986.     if(Args[ARG_PRINT_BITS])
  1987.         Flags |= PRINT_BITS;
  1988.  
  1989.     if((Index = ToList(Args[ARG_PRINT_FROM])) == -1)
  1990.     {
  1991.         if(!Stricmp(Args[ARG_PRINT_FROM],"SCREENTEXT"))
  1992.         {
  1993.             if(!RasterEnabled)
  1994.             {
  1995.                 Results[0] = RC_ERROR;
  1996.                 Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  1997.  
  1998.                 return(NULL);
  1999.             }
  2000.             else
  2001.                 Mode = 0;
  2002.         }
  2003.  
  2004.         if(!Stricmp(Args[ARG_PRINT_FROM],"CLIPBOARD"))
  2005.             Mode = 1;
  2006.  
  2007.         if(!Stricmp(Args[ARG_PRINT_FROM],"BUFFER"))
  2008.             Mode = 2;
  2009.     }
  2010.  
  2011.     if(Index == -1 && Mode == -1)
  2012.     {
  2013.         Results[0] = RC_ERROR;
  2014.         Results[1] = TERMERROR_UNKNOWN_LIST;
  2015.     }
  2016.     else
  2017.     {
  2018.         BYTE    Continue = TRUE;
  2019.         LONG    Error = 0;
  2020.         BPTR    File;
  2021.         STRPTR    Name;
  2022.  
  2023.         if(Args[ARG_PRINT_TO])
  2024.             Name = Args[ARG_PRINT_TO];
  2025.         else
  2026.             Name = "PRT:";
  2027.  
  2028.         if(File = Open(Name,MODE_NEWFILE))
  2029.         {
  2030.             struct Window        *ReqWindow;
  2031.             struct EasyStruct     Easy;
  2032.  
  2033.             Easy . es_StructSize    = sizeof(struct EasyStruct);
  2034.             Easy . es_Flags        = NULL;
  2035.             Easy . es_Title        = (UBYTE *)LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  2036.             Easy . es_GadgetFormat    = (UBYTE *)LocaleString(MSG_PRINT_STOP_TXT);
  2037.             Easy . es_TextFormat    = (UBYTE *)LocaleString(MSG_GLOBAL_PRINTING_TXT);
  2038.  
  2039.             BlockWindows();
  2040.  
  2041.             if(ReqWindow = BuildEasyRequest(Window,&Easy,NULL))
  2042.             {
  2043.                 switch(Index)
  2044.                 {
  2045.                     case GLIST_DIAL:
  2046.                     {
  2047.                         struct GenericList *List = GenericListTable[Index];
  2048.  
  2049.                         ObtainSemaphore(&List -> ListSemaphore);
  2050.  
  2051.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2052.                         {
  2053.                             struct DialNode *TempNode;
  2054.  
  2055.                             for(TempNode = (struct DialNode *)List -> ListHeader . mlh_Head ; Continue && TempNode -> Node . ln_Succ ; TempNode = (struct DialNode *)TempNode -> Node . ln_Succ)
  2056.                             {
  2057.                                 if(TempNode -> Entry)
  2058.                                     Continue = PrintEntry(File,ReqWindow,TRUE,&Error,TempNode -> Entry,Flags);
  2059.                                 else
  2060.                                     Continue = PrintText(File,ReqWindow,&Error,"\n\"???\" (%s)",TempNode -> Node . ln_Name);
  2061.                             }
  2062.                         }
  2063.  
  2064.                         ReleaseSemaphore(&List -> ListSemaphore);
  2065.                     }
  2066.  
  2067.                     break;
  2068.  
  2069.                     case GLIST_UPLOAD:
  2070.                     case GLIST_DOWNLOAD:
  2071.                     {
  2072.                         struct GenericList *List = GenericListTable[Index];
  2073.  
  2074.                         ObtainSemaphore(&List -> ListSemaphore);
  2075.  
  2076.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2077.                         {
  2078.                             struct Node *TempNode;
  2079.  
  2080.                             for(TempNode = (struct Node *)List -> ListHeader . mlh_Head ; Continue && TempNode -> ln_Succ ; TempNode = TempNode -> ln_Succ)
  2081.                                 Continue = PrintFileInformation(File,ReqWindow,&Error,TempNode -> ln_Name,Flags);
  2082.                         }
  2083.  
  2084.                         ReleaseSemaphore(&List -> ListSemaphore);
  2085.                     }
  2086.  
  2087.                     break;
  2088.  
  2089.                     case GLIST_WAIT:
  2090.                     {
  2091.                         struct GenericList *List = GenericListTable[Index];
  2092.  
  2093.                         ObtainSemaphore(&List -> ListSemaphore);
  2094.  
  2095.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2096.                         {
  2097.                             struct Node *TempNode;
  2098.  
  2099.                             for(TempNode = (struct Node *)List -> ListHeader . mlh_Head ; Continue && TempNode -> ln_Succ ; TempNode = TempNode -> ln_Succ)
  2100.                                 Continue = PrintText(File,ReqWindow,&Error,"%s\n",TempNode -> ln_Name);
  2101.                         }
  2102.  
  2103.                         ReleaseSemaphore(&List -> ListSemaphore);
  2104.                     }
  2105.  
  2106.                     break;
  2107.  
  2108.                     default:
  2109.                     {
  2110.                         switch(Mode)
  2111.                         {
  2112.                             case 0:
  2113.  
  2114.                                 Continue = PrintScreen(File,ReqWindow,&Error);
  2115.                                 break;
  2116.  
  2117.                             case 1:
  2118.  
  2119.                                 Continue = PrintClip(File,ReqWindow,&Error);
  2120.                                 break;
  2121.  
  2122.                             case 2:
  2123.  
  2124.                                 Continue = PrintBuffer(File,ReqWindow,&Error);
  2125.                                 break;
  2126.                         }
  2127.  
  2128.                         break;
  2129.                     }
  2130.  
  2131.                     break;
  2132.                 }
  2133.  
  2134.                 FreeSysRequest(ReqWindow);
  2135.             }
  2136.  
  2137.             ReleaseWindows();
  2138.  
  2139.             Close(File);
  2140.         }
  2141.         else
  2142.             Error = IoErr();
  2143.  
  2144.         if(Error)
  2145.         {
  2146.             Results[0] = RC_ERROR;
  2147.             Results[1] = Error;
  2148.         }
  2149.         else
  2150.         {
  2151.             if(!Continue)
  2152.                 Results[0] = RC_WARN;
  2153.         }
  2154.     }
  2155.  
  2156.     return(NULL);
  2157. }
  2158.  
  2159. STRPTR
  2160. RexxProcessIO(struct RexxPkt *Pkt)
  2161. {
  2162.     enum    {    ARG_PROCESSIO_ON,ARG_PROCESSIO_OFF };
  2163.  
  2164.     Forbid();
  2165.  
  2166.     if(Args[ARG_PROCESSIO_ON])
  2167.         ProcessIO = TRUE;
  2168.  
  2169.     if(Args[ARG_PROCESSIO_OFF])
  2170.         ProcessIO = FALSE;
  2171.  
  2172.     Permit();
  2173.  
  2174.     return(NULL);
  2175. }
  2176.  
  2177. STRPTR
  2178. RexxProtocol(struct RexxPkt *Pkt)
  2179. {
  2180.     enum    {    ARG_PROTOCOL_NONE,ARG_PROTOCOL_RTSCTS,ARG_PROTOCOL_RTSCTSDTR };
  2181.  
  2182.     BYTE Mode;
  2183.  
  2184.     if(Args[ARG_PROTOCOL_NONE])
  2185.         Mode = HANDSHAKING_NONE;
  2186.  
  2187.     if(Args[ARG_PROTOCOL_RTSCTS])
  2188.         Mode = HANDSHAKING_RTSCTS;
  2189.  
  2190.     if(Args[ARG_PROTOCOL_RTSCTSDTR])
  2191.         Mode = HANDSHAKING_RTSCTS_DSR;
  2192.  
  2193.     if(Config -> SerialConfig -> HandshakingProtocol != Mode)
  2194.     {
  2195.         Config -> SerialConfig -> HandshakingProtocol = Mode;
  2196.  
  2197.         UpdateRequired = TRUE;
  2198.  
  2199.         ConfigChanged = TRUE;
  2200.     }
  2201.  
  2202.     return(NULL);
  2203. }
  2204.  
  2205. STRPTR
  2206. RexxPutClip(struct RexxPkt *Pkt)
  2207. {
  2208.     enum    {    ARG_PUTCLIP_UNIT,ARG_PUTCLIP_TEXT };
  2209.  
  2210.     struct IFFHandle    *Handle;
  2211.     LONG             Unit;
  2212.     BYTE             Success = FALSE;
  2213.  
  2214.     if(Args[ARG_PUTCLIP_UNIT])
  2215.         Unit = *(LONG *)Args[ARG_PUTCLIP_UNIT];
  2216.     else
  2217.         Unit = Config -> ClipConfig -> ClipboardUnit;
  2218.  
  2219.     if(Handle = AllocIFF())
  2220.     {
  2221.         if(Handle -> iff_Stream = (ULONG)OpenClipboard(Unit))
  2222.         {
  2223.             InitIFFasClip(Handle);
  2224.  
  2225.             if(!OpenIFF(Handle,IFFF_WRITE))
  2226.             {
  2227.                 if(!PushChunk(Handle,ID_FTXT,ID_FORM,IFFSIZE_UNKNOWN))
  2228.                 {
  2229.                     if(!PushChunk(Handle,0,ID_CHRS,IFFSIZE_UNKNOWN))
  2230.                     {
  2231.                         LONG Len = strlen(Args[ARG_PUTCLIP_TEXT]);
  2232.  
  2233.                         if(WriteChunkBytes(Handle,Args[ARG_PUTCLIP_TEXT],Len) == Len)
  2234.                         {
  2235.                             if(!PopChunk(Handle))
  2236.                                 Success = TRUE;
  2237.                         }
  2238.                     }
  2239.                 }
  2240.  
  2241.                 if(PopChunk(Handle))
  2242.                     Success = FALSE;
  2243.  
  2244.                 CloseIFF(Handle);
  2245.             }
  2246.             else
  2247.             {
  2248.                 Results[0] = RC_ERROR;
  2249.                 Results[1] = ERROR_NO_FREE_STORE;
  2250.             }
  2251.  
  2252.             CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  2253.         }
  2254.         else
  2255.         {
  2256.             Results[0] = RC_ERROR;
  2257.             Results[1] = TERMERROR_UNIT_NOT_AVAILABLE;
  2258.         }
  2259.  
  2260.         FreeIFF(Handle);
  2261.     }
  2262.     else
  2263.     {
  2264.         Results[0] = RC_ERROR;
  2265.         Results[1] = ERROR_NO_FREE_STORE;
  2266.     }
  2267.  
  2268.     if(!Success && !Results[0])
  2269.     {
  2270.         Results[0] = RC_ERROR;
  2271.         Results[1] = TERMERROR_CLIPBOARD_ERROR;
  2272.     }
  2273.  
  2274.     return(NULL);
  2275. }
  2276.  
  2277. STRPTR
  2278. RexxQuit(struct RexxPkt *Pkt)
  2279. {
  2280.     enum    {    ARG_QUIT_FORCE };
  2281.  
  2282.     struct DataMsg *Msg;
  2283.  
  2284.     if(Msg = (struct DataMsg *)CreateMsgItem(sizeof(struct DataMsg)))
  2285.     {
  2286.         Pkt -> RexxMsg -> rm_Result1 = RC_WARN;
  2287.         Pkt -> RexxMsg -> rm_Result2 = 0;
  2288.  
  2289.         ReplyMsg(Pkt -> RexxMsg);
  2290.  
  2291.         Pkt -> RexxMsg = NULL;
  2292.  
  2293.         Msg -> Type = DATAMSGTYPE_MENU;
  2294.         Msg -> Size = MEN_QUIT;
  2295.  
  2296.         if(Args[ARG_QUIT_FORCE])
  2297.             Msg -> Data = (APTR)(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT);
  2298.         else
  2299.             Msg -> Data = NULL;
  2300.  
  2301.         PutMsgItem(SpecialQueue,(struct MsgItem *)Msg);
  2302.     }
  2303.     else
  2304.     {
  2305.         Results[0] = RC_ERROR;
  2306.         Results[1] = ERROR_NO_FREE_STORE;
  2307.     }
  2308.  
  2309.     return(NULL);
  2310. }
  2311.  
  2312. STATIC STRPTR    RexxReadBuffer;
  2313. STATIC LONG    RexxReadIndex,
  2314.         RexxReadLen;
  2315. STATIC BYTE    RexxReadDone,
  2316.         RexxReadEcho;
  2317.  
  2318. STATIC BOOLEAN
  2319. RexxReadBypassVerbatim(STRPTR Buffer,LONG Size)
  2320. {
  2321.     while(Size-- > 0)
  2322.     {
  2323.         switch(*Buffer)
  2324.         {
  2325.             case '\n':
  2326.  
  2327.                 break;
  2328.  
  2329.             case '\r':
  2330.  
  2331.                 RexxReadDone = TRUE;
  2332.                 break;
  2333.  
  2334.             case '\b':
  2335.             case '\30':
  2336.  
  2337.                 while(RexxReadIndex > 0)
  2338.                 {
  2339.                     if(RexxReadEcho)
  2340.                         SerWriteVerbatim("\b",1,FALSE);
  2341.  
  2342.                     RexxReadIndex--;
  2343.                 }
  2344.  
  2345.                 break;
  2346.  
  2347.             default:
  2348.  
  2349.                 if(RexxReadIndex < RexxReadLen && ((*Buffer >= ' ' && *Buffer < 127) || *Buffer >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2350.                 {
  2351.                     RexxReadBuffer[RexxReadIndex++] = *Buffer;
  2352.  
  2353.                     if(RexxReadEcho)
  2354.                         SerWriteVerbatim(Buffer,1,FALSE);
  2355.                 }
  2356.  
  2357.                 break;
  2358.         }
  2359.  
  2360.         Buffer++;
  2361.     }
  2362.  
  2363.     return(FALSE);
  2364. }
  2365.  
  2366. STATIC BOOLEAN
  2367. RexxReadBypassTranslate(STRPTR Buffer,LONG Size)
  2368. {
  2369.     struct TranslationHandle    Handle;
  2370.     UBYTE                Temp;
  2371.  
  2372.     while(Size-- > 0)
  2373.     {
  2374.         TranslateSetup(&Handle,Buffer,1,&Temp,1,ReceiveTable);
  2375.  
  2376.         while(!RexxReadDone && TranslateBuffer(&Handle))
  2377.         {
  2378.             switch(Temp)
  2379.             {
  2380.                 case '\n':
  2381.  
  2382.                     break;
  2383.  
  2384.                 case '\r':
  2385.  
  2386.                     RexxReadDone = TRUE;
  2387.  
  2388.                     break;
  2389.  
  2390.                 case '\b':
  2391.                 case '\30':
  2392.  
  2393.                     while(RexxReadIndex > 0)
  2394.                     {
  2395.                         if(RexxReadEcho)
  2396.                             SerWriteVerbatim("\b",1,FALSE);
  2397.  
  2398.                         RexxReadIndex--;
  2399.                     }
  2400.  
  2401.                     break;
  2402.  
  2403.                 default:
  2404.  
  2405.                     if(RexxReadIndex < RexxReadLen && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2406.                     {
  2407.                         RexxReadBuffer[RexxReadIndex++] = Temp;
  2408.  
  2409.                         if(RexxReadEcho)
  2410.                             SerWriteVerbatim(&Temp,1,FALSE);
  2411.                     }
  2412.  
  2413.                     break;
  2414.             }
  2415.         }
  2416.  
  2417.         Buffer++;
  2418.     }
  2419.  
  2420.     return(FALSE);
  2421. }
  2422.  
  2423. STRPTR
  2424. RexxRead(struct RexxPkt *Pkt)
  2425. {
  2426.     enum    {    ARG_READ_NUM,ARG_READ_CR,ARG_READ_NOECHO,ARG_READ_VERBATIM,ARG_READ_PROMPT };
  2427.  
  2428.     LONG Len,BytesRead = 0;
  2429.  
  2430.     if(!ReadRequest || !WriteRequest)
  2431.     {
  2432.         Results[0] = RC_WARN;
  2433.  
  2434.         return(NULL);
  2435.     }
  2436.  
  2437.     if(Args[ARG_READ_NUM])
  2438.     {
  2439.         Len = *(LONG *)Args[ARG_READ_NUM] + 1;
  2440.  
  2441.         if(Len < 1)
  2442.         {
  2443.             Results[0] = RC_ERROR;
  2444.             Results[1] = ERROR_BAD_NUMBER;
  2445.  
  2446.             return(NULL);
  2447.         }
  2448.  
  2449.         if(Len > MAX_RESULT_LEN + 1)
  2450.             Len = MAX_RESULT_LEN + 1;
  2451.     }
  2452.     else
  2453.         Len = MAX_RESULT_LEN + 1;
  2454.  
  2455.     if(Args[ARG_READ_PROMPT])
  2456.         SerialCommand(Args[ARG_READ_PROMPT]);
  2457.  
  2458.     if(Marking)
  2459.         DropMarker();
  2460.  
  2461.     BlockWindows();
  2462.  
  2463.     if(Args[ARG_READ_CR])
  2464.     {
  2465.         Forbid();
  2466.  
  2467.         LT_UnlockWindow(Window);
  2468.  
  2469.         Window -> Flags |= WFLG_RMBTRAP;
  2470.  
  2471.         Permit();
  2472.  
  2473.         NormalCursor();
  2474.     }
  2475.  
  2476.     Status = STATUS_READY;
  2477.  
  2478.     if(Args[ARG_READ_VERBATIM] || !ReceiveTable)
  2479.     {
  2480.         if(Args[ARG_READ_CR])
  2481.         {
  2482.             ULONG     Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2483.             UBYTE    *Char = ReadBuffer;
  2484.             BYTE     Echo,Done = FALSE;
  2485.             LONG     Index = 0;
  2486.             STRPTR     Buffer;
  2487.  
  2488.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2489.             {
  2490.                 if(Args[ARG_READ_NOECHO])
  2491.                     Echo = FALSE;
  2492.                 else
  2493.                     Echo = TRUE;
  2494.  
  2495.                 RexxReadEcho = Echo;
  2496.  
  2497.                 if(RexxTimeoutVal)
  2498.                     StartTime(RexxTimeoutVal,0);
  2499.  
  2500.                 if(DataHold)
  2501.                 {
  2502.                     while(DataSize-- > 0)
  2503.                     {
  2504.                         Char = DataHold++;
  2505.  
  2506.                         switch(*Char)
  2507.                         {
  2508.                             case '\n':
  2509.  
  2510.                                 break;
  2511.  
  2512.                             case '\r':
  2513.  
  2514.                                 Done = TRUE;
  2515.  
  2516.                                 if(Echo)
  2517.                                     SerWrite(ReadBuffer,1);
  2518.  
  2519.                                 break;
  2520.  
  2521.                             case '\b':
  2522.  
  2523.                                 if(Index > 0)
  2524.                                 {
  2525.                                     Index--;
  2526.  
  2527.                                     if(Echo)
  2528.                                         SerWrite(ReadBuffer,1);
  2529.                                 }
  2530.  
  2531.                                 break;
  2532.  
  2533.                             case '\30':
  2534.  
  2535.                                 if(Echo)
  2536.                                 {
  2537.                                     while(Index > 0)
  2538.                                     {
  2539.                                         Index--;
  2540.  
  2541.                                         SerWrite("\b",1);
  2542.                                     }
  2543.                                 }
  2544.                                 else
  2545.                                     Index = 0;
  2546.  
  2547.                                 break;
  2548.  
  2549.                             default:
  2550.  
  2551.                                 if(Index < Len && ((*Char >= ' ' && *Char < 127) || *Char >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2552.                                 {
  2553.                                     Buffer[Index++] = *Char;
  2554.  
  2555.                                     if(Echo)
  2556.                                         SerWrite(ReadBuffer,1);
  2557.                                 }
  2558.  
  2559.                                 break;
  2560.                         }
  2561.                     }
  2562.  
  2563.                     DataHold = NULL;
  2564.  
  2565.                     RestartSerial(TRUE);
  2566.                 }
  2567.  
  2568.                 if(CheckSerialRead())
  2569.                     Signals = SIG_SERIAL;
  2570.                 else
  2571.                     Signals = NULL;
  2572.  
  2573.                 do
  2574.                 {
  2575.                     if(Signals & SIG_WINDOW)
  2576.                     {
  2577.                         SerWriteBypass = RexxReadBypassVerbatim;
  2578.  
  2579.                         RexxReadBuffer    = Buffer;
  2580.                         RexxReadIndex    = Index;
  2581.                         RexxReadLen    = Len;
  2582.                         RexxReadDone    = Done;
  2583.  
  2584.                         while(HandleWindow());
  2585.  
  2586.                         Buffer    = RexxReadBuffer;
  2587.                         Index    = RexxReadIndex;
  2588.                         Len    = RexxReadLen;
  2589.                         Done    = RexxReadDone;
  2590.  
  2591.                         SerWriteBypass = NULL;
  2592.                     }
  2593.  
  2594.                     if(Signals & SIG_SERIAL)
  2595.                     {
  2596.                         if(!WaitSerialRead())
  2597.                         {
  2598.                             LONG Length;
  2599.  
  2600.                             BytesIn++;
  2601.  
  2602.                             if(Translate_CR_LF)
  2603.                                 Length = (* Translate_CR_LF)(ReadBuffer,1);
  2604.                             else
  2605.                                 Length = 1;
  2606.  
  2607.                             while(Length--)
  2608.                             {
  2609.                                 switch(*Char)
  2610.                                 {
  2611.                                     case '\n':
  2612.  
  2613.                                         break;
  2614.  
  2615.                                     case '\r':
  2616.  
  2617.                                         Done = TRUE;
  2618.  
  2619.                                         if(Echo)
  2620.                                             SerWrite(ReadBuffer,1);
  2621.  
  2622.                                         break;
  2623.  
  2624.                                     case '\b':
  2625.  
  2626.                                         if(Index > 0)
  2627.                                         {
  2628.                                             Index--;
  2629.  
  2630.                                             if(Echo)
  2631.                                                 SerWrite(ReadBuffer,1);
  2632.                                         }
  2633.  
  2634.                                         break;
  2635.  
  2636.                                     case '\30':
  2637.  
  2638.                                         if(Echo)
  2639.                                         {
  2640.                                             while(Index > 0)
  2641.                                             {
  2642.                                                 Index--;
  2643.  
  2644.                                                 SerWrite("\b",1);
  2645.                                             }
  2646.                                         }
  2647.                                         else
  2648.                                             Index = 0;
  2649.  
  2650.                                     default:
  2651.  
  2652.                                         if(Index < Len && ((*Char >= ' ' && *Char < 127) || *Char >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2653.                                         {
  2654.                                             Buffer[Index++] = *Char;
  2655.  
  2656.                                             if(Echo)
  2657.                                                 SerWrite(ReadBuffer,1);
  2658.                                         }
  2659.  
  2660.                                         break;
  2661.                                 }
  2662.  
  2663.                                 Char++;
  2664.                             }
  2665.                         }
  2666.  
  2667.                         RestartSerial(TRUE);
  2668.                     }
  2669.  
  2670.                     if(Signals & (SIG_BREAK | SIG_TIMER))
  2671.                     {
  2672.                         Results[0] = RC_WARN;
  2673.  
  2674.                         break;
  2675.                     }
  2676.  
  2677.                     if(!Done)
  2678.                         Signals = Wait(SignalMask | SIG_WINDOW);
  2679.                 }
  2680.                 while(!Done);
  2681.  
  2682.                 if(RexxTimeoutVal)
  2683.                     StopTime();
  2684.  
  2685.                 if(Index)
  2686.                 {
  2687.                     STRPTR Result;
  2688.  
  2689.                     Buffer[Index] = 0;
  2690.  
  2691.                     Result = CreateResult(Buffer,Results);
  2692.  
  2693.                     if(Args[ARG_READ_CR])
  2694.                     {
  2695.                         Forbid();
  2696.  
  2697.                         Window -> Flags &= ~WFLG_RMBTRAP;
  2698.  
  2699.                         LT_LockWindow(Window);
  2700.  
  2701.                         Permit();
  2702.                     }
  2703.  
  2704.                     ReleaseWindows();
  2705.  
  2706.                     FreeVecPooled(Buffer);
  2707.  
  2708.                     return(Result);
  2709.                 }
  2710.                 else
  2711.                     Results[0] = RC_WARN;
  2712.  
  2713.                 FreeVecPooled(Buffer);
  2714.             }
  2715.             else
  2716.             {
  2717.                 Results[0] = RC_ERROR;
  2718.                 Results[1] = ERROR_NO_FREE_STORE;
  2719.             }
  2720.         }
  2721.         else
  2722.         {
  2723.             STRPTR Buffer;
  2724.  
  2725.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2726.             {
  2727.                 STRPTR Result;
  2728.  
  2729.                 if(DataHold && DataSize >= Len - 1)
  2730.                 {
  2731.                     CopyMem(DataHold,Buffer,Len - 1);
  2732.  
  2733.                     BytesRead = Len - 1;
  2734.  
  2735.                     if(DataSize == Len - 1)
  2736.                     {
  2737.                         DataHold = NULL;
  2738.  
  2739.                         RestartSerial(TRUE);
  2740.                     }
  2741.                     else
  2742.                     {
  2743.                         DataHold += Len - 1;
  2744.                         DataSize -= Len - 1;
  2745.                     }
  2746.                 }
  2747.                 else
  2748.                 {
  2749.                     ULONG Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2750.  
  2751.                     ClearSerial();
  2752.  
  2753.                     ClrSignal(SignalMask);
  2754.  
  2755.                     if(RexxTimeoutVal)
  2756.                         StartTime(RexxTimeoutVal,0);
  2757.  
  2758.                     if(DataHold)
  2759.                     {
  2760.                         CopyMem(DataHold,Buffer,DataSize);
  2761.  
  2762.                         StartSerialRead(Buffer + DataSize,Len - 1 - DataSize);
  2763.  
  2764.                         BytesRead = DataSize;
  2765.  
  2766.                         DataHold = NULL;
  2767.                     }
  2768.                     else
  2769.                         StartSerialRead(Buffer,Len - 1);
  2770.  
  2771.                     FOREVER
  2772.                     {
  2773.                         Signals = Wait(SignalMask);
  2774.  
  2775.                         if(Signals & SIG_SERIAL)
  2776.                         {
  2777.                             if(RexxTimeoutVal)
  2778.                                 StopTime();
  2779.  
  2780.                                 /* Did the request terminate gracefully? */
  2781.  
  2782.                             if(!WaitSerialRead())
  2783.                             {
  2784.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  2785.  
  2786.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  2787.                             }
  2788.                             else
  2789.                                 Results[0] = RC_ERROR;
  2790.  
  2791.                             break;
  2792.                         }
  2793.  
  2794.                         if(Signals & SIG_BREAK)
  2795.                         {
  2796.                             StopSerialRead();
  2797.  
  2798.                             if(RexxTimeoutVal)
  2799.                                 StopTime();
  2800.  
  2801.                             Results[0] = RC_WARN;
  2802.  
  2803.                             break;
  2804.                         }
  2805.  
  2806.                         if(Signals & SIG_TIMER)
  2807.                         {
  2808.                             StopSerialRead();
  2809.  
  2810.                             WaitIO(TimeRequest);
  2811.  
  2812.                             if(ReadRequest -> IOSer . io_Actual)
  2813.                             {
  2814.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  2815.  
  2816.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  2817.                             }
  2818.                             else
  2819.                             {
  2820.                                 ULONG Waiting = GetSerialWaiting();
  2821.  
  2822.                                 if(Waiting)
  2823.                                 {
  2824.                                         /* Don't read more than actually wanted. */
  2825.  
  2826.                                     if(!DoSerialRead(Buffer,MIN(Len - 1,Waiting)))
  2827.                                     {
  2828.                                         BytesIn += ReadRequest -> IOSer . io_Actual;
  2829.  
  2830.                                         BytesRead = ReadRequest -> IOSer . io_Actual;
  2831.                                     }
  2832.                                 }
  2833.                             }
  2834.  
  2835.                             break;
  2836.                         }
  2837.                     }
  2838.                 }
  2839.  
  2840.                 if(BytesRead)
  2841.                     Result = CreateResultLen(Buffer,Results,BytesRead);
  2842.                 else
  2843.                 {
  2844.                     Results[0] = RC_WARN;
  2845.  
  2846.                     Result = NULL;
  2847.                 }
  2848.  
  2849.                 FreeVecPooled(Buffer);
  2850.  
  2851.                 RestartSerial(TRUE);
  2852.  
  2853.                 if(Args[ARG_READ_CR])
  2854.                 {
  2855.                     Forbid();
  2856.  
  2857.                     Window -> Flags &= ~WFLG_RMBTRAP;
  2858.  
  2859.                     LT_LockWindow(Window);
  2860.  
  2861.                     Permit();
  2862.                 }
  2863.  
  2864.                 ReleaseWindows();
  2865.  
  2866.                 return(Result);
  2867.             }
  2868.             else
  2869.             {
  2870.                 Results[0] = RC_ERROR;
  2871.                 Results[1] = ERROR_NO_FREE_STORE;
  2872.             }
  2873.  
  2874.             RestartSerial(TRUE);
  2875.         }
  2876.     }
  2877.     else
  2878.     {
  2879.         if(Args[ARG_READ_CR])
  2880.         {
  2881.             ULONG                 Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2882.             UBYTE                *Char,Temp;
  2883.             BYTE                 Echo,Done = FALSE;
  2884.             LONG                 Index = 0;
  2885.             struct TranslationHandle     Handle;
  2886.             STRPTR                 Buffer;
  2887.  
  2888.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2889.             {
  2890.                 if(Args[ARG_READ_NOECHO])
  2891.                     Echo = FALSE;
  2892.                 else
  2893.                     Echo = TRUE;
  2894.  
  2895.                 RexxReadEcho = Echo;
  2896.  
  2897.                 if(RexxTimeoutVal)
  2898.                     StartTime(RexxTimeoutVal,0);
  2899.  
  2900.                 if(DataHold)
  2901.                 {
  2902.                     while(DataSize-- > 0)
  2903.                     {
  2904.                         Char = DataHold++;
  2905.  
  2906.                         TranslateSetup(&Handle,Char,1,&Temp,1,ReceiveTable);
  2907.  
  2908.                         while(!Done && TranslateBuffer(&Handle))
  2909.                         {
  2910.                             switch(Temp)
  2911.                             {
  2912.                                 case '\n':
  2913.  
  2914.                                     break;
  2915.  
  2916.                                 case '\r':
  2917.  
  2918.                                     Done = TRUE;
  2919.  
  2920.                                     if(Echo)
  2921.                                         SerWrite(&Temp,1);
  2922.  
  2923.                                     break;
  2924.  
  2925.                                 case '\b':
  2926.  
  2927.                                     if(Index > 0)
  2928.                                     {
  2929.                                         Index--;
  2930.  
  2931.                                         if(Echo)
  2932.                                             SerWrite(&Temp,1);
  2933.                                     }
  2934.  
  2935.                                     break;
  2936.  
  2937.                                 case '\30':
  2938.  
  2939.                                     if(Echo)
  2940.                                     {
  2941.                                         while(Index > 0)
  2942.                                         {
  2943.                                             Index--;
  2944.  
  2945.                                             SerWrite("\b",1);
  2946.                                         }
  2947.                                     }
  2948.                                     else
  2949.                                         Index = 0;
  2950.  
  2951.                                     break;
  2952.  
  2953.                                 default:
  2954.  
  2955.                                     if(Index < Len && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2956.                                     {
  2957.                                         Buffer[Index++] = Temp;
  2958.  
  2959.                                         if(Echo)
  2960.                                             SerWrite(&Temp,1);
  2961.                                     }
  2962.  
  2963.                                     break;
  2964.                             }
  2965.                         }
  2966.                     }
  2967.  
  2968.                     DataHold = NULL;
  2969.  
  2970.                     RestartSerial(TRUE);
  2971.                 }
  2972.  
  2973.                 if(CheckSerialRead())
  2974.                     Signals = SIG_SERIAL;
  2975.                 else
  2976.                     Signals = NULL;
  2977.  
  2978.                 do
  2979.                 {
  2980.                     if(Signals & SIG_WINDOW)
  2981.                     {
  2982.                         SerWriteBypass = RexxReadBypassTranslate;
  2983.  
  2984.                         RexxReadBuffer    = Buffer;
  2985.                         RexxReadIndex    = Index;
  2986.                         RexxReadLen    = Len;
  2987.                         RexxReadDone    = Done;
  2988.  
  2989.                         while(HandleWindow());
  2990.  
  2991.                         Buffer    = RexxReadBuffer;
  2992.                         Index    = RexxReadIndex;
  2993.                         Len    = RexxReadLen;
  2994.                         Done    = RexxReadDone;
  2995.  
  2996.                         SerWriteBypass = NULL;
  2997.                     }
  2998.  
  2999.                     if(Signals & SIG_SERIAL)
  3000.                     {
  3001.                         if(!WaitSerialRead())
  3002.                         {
  3003.                             LONG Length;
  3004.  
  3005.                             BytesIn++;
  3006.  
  3007.                             if(Translate_CR_LF)
  3008.                                 Length = (* Translate_CR_LF)(ReadBuffer,1);
  3009.                             else
  3010.                                 Length = 1;
  3011.  
  3012.                             if(Length)
  3013.                             {
  3014.                                 TranslateSetup(&Handle,ReadBuffer,Length,&Temp,1,ReceiveTable);
  3015.  
  3016.                                 while(!Done && TranslateBuffer(&Handle))
  3017.                                 {
  3018.                                     switch(Temp)
  3019.                                     {
  3020.                                         case '\n':
  3021.  
  3022.                                             break;
  3023.  
  3024.                                         case '\r':
  3025.  
  3026.                                             Done = TRUE;
  3027.  
  3028.                                             if(Echo)
  3029.                                                 SerWrite(&Temp,1);
  3030.  
  3031.                                             break;
  3032.  
  3033.                                         case '\b':
  3034.  
  3035.                                             if(Index > 0)
  3036.                                             {
  3037.                                                 Index--;
  3038.  
  3039.                                                 if(Echo)
  3040.                                                     SerWrite(&Temp,1);
  3041.                                             }
  3042.  
  3043.                                             break;
  3044.  
  3045.                                         case '\30':
  3046.  
  3047.                                             if(Echo)
  3048.                                             {
  3049.                                                 while(Index > 0)
  3050.                                                 {
  3051.                                                     Index--;
  3052.  
  3053.                                                     SerWrite("\b",1);
  3054.                                                 }
  3055.                                             }
  3056.                                             else
  3057.                                                 Index = 0;
  3058.  
  3059.                                         default:
  3060.  
  3061.                                             if(Index < Len && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  3062.                                             {
  3063.                                                 Buffer[Index++] = Temp;
  3064.  
  3065.                                                 if(Echo)
  3066.                                                     SerWrite(&Temp,1);
  3067.                                             }
  3068.  
  3069.                                             break;
  3070.                                     }
  3071.                                 }
  3072.                             }
  3073.                         }
  3074.  
  3075.                         RestartSerial(TRUE);
  3076.                     }
  3077.  
  3078.                     if(Signals & (SIG_BREAK | SIG_TIMER))
  3079.                     {
  3080.                         Results[0] = RC_WARN;
  3081.  
  3082.                         break;
  3083.                     }
  3084.  
  3085.                     if(!Done)
  3086.                         Signals = Wait(SignalMask | SIG_WINDOW);
  3087.                 }
  3088.                 while(!Done);
  3089.  
  3090.                 if(RexxTimeoutVal)
  3091.                     StopTime();
  3092.  
  3093.                 if(Index)
  3094.                 {
  3095.                     STRPTR Result;
  3096.  
  3097.                     Buffer[Index] = 0;
  3098.  
  3099.                     Result = CreateResult(Buffer,Results);
  3100.  
  3101.                     if(Args[ARG_READ_CR])
  3102.                     {
  3103.                         Forbid();
  3104.  
  3105.                         Window -> Flags &= ~WFLG_RMBTRAP;
  3106.  
  3107.                         LT_LockWindow(Window);
  3108.  
  3109.                         Permit();
  3110.                     }
  3111.  
  3112.                     ReleaseWindows();
  3113.  
  3114.                     FreeVecPooled(Buffer);
  3115.  
  3116.                     return(Result);
  3117.                 }
  3118.                 else
  3119.                     Results[0] = RC_WARN;
  3120.  
  3121.                 FreeVecPooled(Buffer);
  3122.             }
  3123.             else
  3124.             {
  3125.                 Results[0] = RC_ERROR;
  3126.                 Results[1] = ERROR_NO_FREE_STORE;
  3127.             }
  3128.         }
  3129.         else
  3130.         {
  3131.             STRPTR Buffer;
  3132.  
  3133.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  3134.             {
  3135.                 STRPTR Result;
  3136.  
  3137.                 if(DataHold && DataSize >= Len - 1)
  3138.                 {
  3139.                     CopyMem(DataHold,Buffer,Len - 1);
  3140.  
  3141.                     BytesRead = Len - 1;
  3142.  
  3143.                     if(DataSize == Len - 1)
  3144.                     {
  3145.                         DataHold = NULL;
  3146.  
  3147.                         RestartSerial(TRUE);
  3148.                     }
  3149.                     else
  3150.                     {
  3151.                         DataHold += Len - 1;
  3152.                         DataSize -= Len - 1;
  3153.                     }
  3154.                 }
  3155.                 else
  3156.                 {
  3157.                     ULONG Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  3158.  
  3159.                     ClearSerial();
  3160.  
  3161.                     ClrSignal(SignalMask);
  3162.  
  3163.                     if(RexxTimeoutVal)
  3164.                         StartTime(RexxTimeoutVal,0);
  3165.  
  3166.                     if(DataHold)
  3167.                     {
  3168.                         CopyMem(DataHold,Buffer,DataSize);
  3169.  
  3170.                         StartSerialRead(Buffer + DataSize,Len - 1 - DataSize);
  3171.  
  3172.                         BytesRead = DataSize;
  3173.  
  3174.                         DataHold = NULL;
  3175.                     }
  3176.                     else
  3177.                         StartSerialRead(Buffer,Len - 1);
  3178.  
  3179.                     FOREVER
  3180.                     {
  3181.                         Signals = Wait(SignalMask);
  3182.  
  3183.                         if(Signals & SIG_SERIAL)
  3184.                         {
  3185.                             if(RexxTimeoutVal)
  3186.                                 StopTime();
  3187.  
  3188.                                 /* Did the request terminate gracefully? */
  3189.  
  3190.                             if(!WaitSerialRead())
  3191.                             {
  3192.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  3193.  
  3194.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  3195.                             }
  3196.                             else
  3197.                                 Results[0] = RC_ERROR;
  3198.  
  3199.                             break;
  3200.                         }
  3201.  
  3202.                         if(Signals & SIG_BREAK)
  3203.                         {
  3204.                             StopSerialRead();
  3205.  
  3206.                             if(RexxTimeoutVal)
  3207.                                 StopTime();
  3208.  
  3209.                             Results[0] = RC_WARN;
  3210.  
  3211.                             break;
  3212.                         }
  3213.  
  3214.                         if(Signals & SIG_TIMER)
  3215.                         {
  3216.                             StopSerialRead();
  3217.  
  3218.                             WaitIO(TimeRequest);
  3219.  
  3220.                             if(ReadRequest -> IOSer . io_Actual)
  3221.                             {
  3222.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  3223.  
  3224.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  3225.                             }
  3226.                             else
  3227.                             {
  3228.                                 ULONG Waiting = GetSerialWaiting();
  3229.  
  3230.                                 if(Waiting)
  3231.                                 {
  3232.                                         /* Don't read more than actually wanted. */
  3233.  
  3234.                                     if(!DoSerialRead(Buffer,MIN(Len - 1,Waiting)))
  3235.                                     {
  3236.                                         BytesIn += ReadRequest -> IOSer . io_Actual;
  3237.  
  3238.                                         BytesRead = ReadRequest -> IOSer . io_Actual;
  3239.                                     }
  3240.                                 }
  3241.                             }
  3242.  
  3243.                             break;
  3244.                         }
  3245.                     }
  3246.                 }
  3247.  
  3248.                 if(BytesRead)
  3249.                 {
  3250.                     STRPTR MetaBuffer;
  3251.  
  3252.                     if(MetaBuffer = AllocVecPooled(Len,MEMF_ANY))
  3253.                     {
  3254.                         struct TranslationHandle    Handle;
  3255.                         LONG                Bytes;
  3256.  
  3257.                         TranslateSetup(&Handle,Buffer,BytesRead,MetaBuffer,Len - 1,ReceiveTable);
  3258.  
  3259.                         Bytes = TranslateBuffer(&Handle);
  3260.  
  3261.                         Result = CreateResultLen(MetaBuffer,Results,Bytes);
  3262.  
  3263.                         FreeVecPooled(MetaBuffer);
  3264.                     }
  3265.                     else
  3266.                     {
  3267.                         Results[0] = RC_ERROR;
  3268.                         Results[1] = ERROR_NO_FREE_STORE;
  3269.  
  3270.                         Result = NULL;
  3271.                     }
  3272.                 }
  3273.                 else
  3274.                 {
  3275.                     Results[0] = RC_WARN;
  3276.  
  3277.                     Result = NULL;
  3278.                 }
  3279.  
  3280.                 FreeVecPooled(Buffer);
  3281.  
  3282.                 RestartSerial(TRUE);
  3283.  
  3284.                 if(Args[ARG_READ_CR])
  3285.                 {
  3286.                     Forbid();
  3287.  
  3288.                     Window -> Flags &= ~WFLG_RMBTRAP;
  3289.  
  3290.                     LT_LockWindow(Window);
  3291.  
  3292.                     Permit();
  3293.                 }
  3294.  
  3295.                 ReleaseWindows();
  3296.  
  3297.                 return(Result);
  3298.             }
  3299.             else
  3300.             {
  3301.                 Results[0] = RC_ERROR;
  3302.                 Results[1] = ERROR_NO_FREE_STORE;
  3303.             }
  3304.  
  3305.             RestartSerial(TRUE);
  3306.         }
  3307.     }
  3308.  
  3309.     if(Args[ARG_READ_CR])
  3310.     {
  3311.         Forbid();
  3312.  
  3313.         Window -> Flags &= ~WFLG_RMBTRAP;
  3314.  
  3315.         LT_LockWindow(Window);
  3316.  
  3317.         Permit();
  3318.     }
  3319.  
  3320.     ReleaseWindows();
  3321.  
  3322.     return(NULL);
  3323. }
  3324.  
  3325. STRPTR
  3326. RexxReceiveFile(struct RexxPkt *Pkt)
  3327. {
  3328.     enum    {    ARG_RECEIVEFILE_MODE,ARG_RECEIVEFILE_NAME };
  3329.  
  3330.     WORD Mode = TRANSFER_BINARY;
  3331.  
  3332.     if(Args[ARG_RECEIVEFILE_MODE])
  3333.         Mode = ToMode(Args[ARG_RECEIVEFILE_MODE]);
  3334.  
  3335.     if(Mode == -1)
  3336.     {
  3337.         Results[0] = RC_ERROR;
  3338.         Results[1] = ERROR_ACTION_NOT_KNOWN;
  3339.     }
  3340.     else
  3341.     {
  3342.         BlockWindows();
  3343.  
  3344.         switch(Mode)
  3345.         {
  3346.             case TRANSFER_ASCII:
  3347.  
  3348.                 if(ChangeProtocol(Config -> TransferConfig -> ASCIIDownloadLibrary))
  3349.                 {
  3350.                     BinaryTransfer = FALSE;
  3351.  
  3352.                     StartXprReceive(TRANSFER_ASCII,NULL,FALSE);
  3353.  
  3354.                     BinaryTransfer = TRUE;
  3355.  
  3356.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3357.                 }
  3358.                 else
  3359.                 {
  3360.                     Results[0] = RC_ERROR;
  3361.                     Results[1] = ERROR_NO_FREE_STORE;
  3362.                 }
  3363.  
  3364.                 ResetProtocol();
  3365.  
  3366.                 break;
  3367.  
  3368.             case TRANSFER_TEXT:
  3369.  
  3370.                 if(ChangeProtocol(Config -> TransferConfig -> TextDownloadLibrary))
  3371.                 {
  3372.                     BinaryTransfer = FALSE;
  3373.  
  3374.                     StartXprReceive(TRANSFER_TEXT,NULL,FALSE);
  3375.  
  3376.                     BinaryTransfer = TRUE;
  3377.  
  3378.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3379.                 }
  3380.                 else
  3381.                 {
  3382.                     Results[0] = RC_ERROR;
  3383.                     Results[1] = ERROR_NO_FREE_STORE;
  3384.                 }
  3385.  
  3386.                 ResetProtocol();
  3387.  
  3388.                 break;
  3389.  
  3390.             case TRANSFER_BINARY:
  3391.  
  3392.                 if(ChangeProtocol(Config -> TransferConfig -> BinaryDownloadLibrary))
  3393.                 {
  3394.                     BinaryTransfer = TRUE;
  3395.  
  3396.                     StartXprReceive(TRANSFER_BINARY,NULL,FALSE);
  3397.  
  3398.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3399.                 }
  3400.                 else
  3401.                 {
  3402.                     Results[0] = RC_ERROR;
  3403.                     Results[1] = ERROR_NO_FREE_STORE;
  3404.                 }
  3405.  
  3406.                 ResetProtocol();
  3407.  
  3408.                 break;
  3409.         }
  3410.  
  3411.         if(TransferFailed)
  3412.             Results[0] = RC_ERROR;
  3413.  
  3414.         if(TransferAborted)
  3415.             Results[0] = RC_WARN;
  3416.  
  3417.         ReleaseWindows();
  3418.     }
  3419.  
  3420.     return(NULL);
  3421. }
  3422.  
  3423. STRPTR
  3424. RexxRedial(struct RexxPkt *Pkt)
  3425. {
  3426.     if(DialList)
  3427.     {
  3428.         if(DialList -> lh_Head -> ln_Succ)
  3429.             DoDial = DIAL_REDIAL;
  3430.         else
  3431.             Results[0] = RC_WARN;
  3432.     }
  3433.     else
  3434.         Results[0] = RC_WARN;
  3435.  
  3436.     return(NULL);
  3437. }
  3438.  
  3439. STRPTR
  3440. RexxRemove(struct RexxPkt *Pkt)
  3441. {
  3442.     enum    {    ARG_REMOVE_FROM,ARG_REMOVE_NAME };
  3443.  
  3444.     WORD Index;
  3445.  
  3446.     if((Index = ToList(Args[ARG_REMOVE_FROM])) == -1)
  3447.     {
  3448.         Results[0] = RC_ERROR;
  3449.         Results[1] = TERMERROR_UNKNOWN_LIST;
  3450.     }
  3451.     else
  3452.     {
  3453.         if(Args[ARG_REMOVE_NAME] && Index == GLIST_DIAL)
  3454.         {
  3455.             Results[0] = RC_ERROR;
  3456.             Results[1] = TERMERROR_DATA_TYPES_INCOMPATIBLE;
  3457.         }
  3458.         else
  3459.         {
  3460.             struct GenericList *List;
  3461.  
  3462.             List = GenericListTable[Index];
  3463.  
  3464.             if(Args[ARG_REMOVE_NAME])
  3465.             {
  3466.                 STRPTR Buffer;
  3467.  
  3468.                 if(Buffer = CreateMatchBuffer(Args[ARG_REMOVE_NAME]))
  3469.                 {
  3470.                     struct Node *Node,*NextNode;
  3471.  
  3472.                     ObtainSemaphore(&List -> ListSemaphore);
  3473.  
  3474.                     Node = (struct Node *)List -> ListHeader . mlh_Head;
  3475.  
  3476.                     while(NextNode = Node -> ln_Succ)
  3477.                     {
  3478.                         if(MatchBuffer(Buffer,Node -> ln_Name))
  3479.                         {
  3480.                             Forbid();
  3481.  
  3482.                             ReleaseSemaphore(&List -> ListSemaphore);
  3483.  
  3484.                             DeleteGenericListNode(List,Node);
  3485.  
  3486.                             ObtainSemaphore(&List -> ListSemaphore);
  3487.  
  3488.                             Permit();
  3489.                         }
  3490.  
  3491.                         Node = NextNode;
  3492.                     }
  3493.  
  3494.                     ReleaseSemaphore(&List -> ListSemaphore);
  3495.  
  3496.                     DeleteMatchBuffer(Buffer);
  3497.                 }
  3498.                 else
  3499.                 {
  3500.                     Results[0] = RC_ERROR;
  3501.                     Results[1] = ERROR_NO_FREE_STORE;
  3502.                 }
  3503.             }
  3504.             else
  3505.                 DeleteGenericListNode(List,NULL);
  3506.  
  3507.             if(!GenericListCount(List))
  3508.                 Results[0] = RC_WARN;
  3509.         }
  3510.     }
  3511.  
  3512.     return(NULL);
  3513. }
  3514.  
  3515. STRPTR
  3516. RexxRequestFile(struct RexxPkt *Pkt)
  3517. {
  3518.     enum    {    ARG_REQUESTFILE_TITLE,ARG_REQUESTFILE_PATH,ARG_REQUESTFILE_FILE,
  3519.             ARG_REQUESTFILE_PATTERN,ARG_REQUESTFILE_MULTI,ARG_REQUESTFILE_NAME };
  3520.  
  3521.     if(Args[ARG_REQUESTFILE_MULTI] && !Args[ARG_REQUESTFILE_NAME])
  3522.     {
  3523.         Results[0] = RC_ERROR;
  3524.         Results[1] = TERMERROR_RESULT_VARIABLE_REQUIRED;
  3525.     }
  3526.     else
  3527.     {
  3528.         struct FileRequester    *FileRequester;
  3529.         UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  3530.                     *DummyChar;
  3531.         STRPTR             FileName,
  3532.                      PathName;
  3533.  
  3534.         if(Args[ARG_REQUESTFILE_PATH])
  3535.         {
  3536.             PathName = Args[ARG_REQUESTFILE_PATH];
  3537.  
  3538.             if(Args[ARG_REQUESTFILE_FILE])
  3539.                 FileName = Args[ARG_REQUESTFILE_FILE];
  3540.             else
  3541.                 FileName = "";
  3542.         }
  3543.         else
  3544.         {
  3545.             PathName = "";
  3546.  
  3547.             if(Args[ARG_REQUESTFILE_FILE])
  3548.             {
  3549.                 strcpy(DummyBuffer,Args[ARG_REQUESTFILE_FILE]);
  3550.  
  3551.                 DummyChar = PathPart(DummyBuffer);
  3552.  
  3553.                 *DummyChar = 0;
  3554.  
  3555.                 PathName = DummyBuffer;
  3556.                 FileName = FilePart(Args[ARG_REQUESTFILE_FILE]);
  3557.             }
  3558.             else
  3559.                 FileName = "";
  3560.         }
  3561.  
  3562.         BlockWindows();
  3563.  
  3564.         if(FileRequester = GetFile(Window,Args[ARG_REQUESTFILE_TITLE],PathName,FileName,DummyBuffer,Args[ARG_REQUESTFILE_PATTERN],FALSE,Args[ARG_REQUESTFILE_MULTI] != NULL,FALSE,"Ok",TRUE))
  3565.         {
  3566.             if(Args[ARG_REQUESTFILE_NAME])
  3567.             {
  3568.                 if(Args[ARG_REQUESTFILE_MULTI])
  3569.                 {
  3570.                     UBYTE         DummyBuffer[MAX_FILENAME_LENGTH];
  3571.                     struct WBArg    *ArgList = FileRequester -> rf_ArgList;
  3572.                     LONG         i,Counted = 0;
  3573.  
  3574.                     for(i = 0 ; i < FileRequester -> rf_NumArgs ; i++)
  3575.                     {
  3576.                         if(ArgList[i] . wa_Name)
  3577.                         {
  3578.                             if(ArgList[i] . wa_Lock)
  3579.                             {
  3580.                                 if(!NameFromLock(ArgList[i] . wa_Lock,DummyBuffer,MAX_FILENAME_LENGTH))
  3581.                                 {
  3582.                                     Results[0] = RC_ERROR;
  3583.                                     Results[1] = IoErr();
  3584.  
  3585.                                     break;
  3586.                                 }
  3587.                             }
  3588.                             else
  3589.                                 strcpy(DummyBuffer,FileRequester -> rf_Dir);
  3590.  
  3591.                             if(AddPart(DummyBuffer,ArgList[i] . wa_Name,MAX_FILENAME_LENGTH))
  3592.                             {
  3593.                                 if(CreateVarArgs(DummyBuffer,Pkt,"%s.%ld",Args[ARG_REQUESTFILE_NAME],i))
  3594.                                     Counted++;
  3595.                                 else
  3596.                                     break;
  3597.                             }
  3598.                             else
  3599.                             {
  3600.                                 Results[0] = RC_ERROR;
  3601.                                 Results[1] = IoErr();
  3602.  
  3603.                                 break;
  3604.                             }
  3605.                         }
  3606.                     }
  3607.  
  3608.                     if(Counted)
  3609.                     {
  3610.                         SPrintf(DummyBuffer,"%ld",Counted);
  3611.  
  3612.                         CreateVarArgs(DummyBuffer,Pkt,"%s.COUNT",Args[ARG_REQUESTFILE_NAME]);
  3613.                     }
  3614.  
  3615.                     FreeAslRequest(FileRequester);
  3616.                 }
  3617.                 else
  3618.                 {
  3619.                     FreeAslRequest(FileRequester);
  3620.  
  3621.                     ReleaseWindows();
  3622.  
  3623.                     return(CreateVar(DummyBuffer,Pkt,Args[ARG_REQUESTFILE_NAME]));
  3624.                 }
  3625.             }
  3626.             else
  3627.             {
  3628.                 FreeAslRequest(FileRequester);
  3629.  
  3630.                 ReleaseWindows();
  3631.  
  3632.                 return(CreateResult(DummyBuffer,Results));
  3633.             }
  3634.         }
  3635.         else
  3636.             Results[0] = RC_WARN;
  3637.  
  3638.         ReleaseWindows();
  3639.     }
  3640.  
  3641.     return(NULL);
  3642. }
  3643.  
  3644. STRPTR
  3645. RexxRequestNotify(struct RexxPkt *Pkt)
  3646. {
  3647.     enum    {    ARG_REQUESTNOTIFY_TITLE,ARG_REQUESTNOTIFY_PROMPT };
  3648.  
  3649.     struct EasyStruct    Easy;
  3650.     ULONG            IDCMP = NULL;
  3651.  
  3652.     Easy . es_StructSize    = sizeof(struct EasyStruct);
  3653.     Easy . es_Flags        = NULL;
  3654.     Easy . es_TextFormat    = Args[ARG_REQUESTNOTIFY_PROMPT];
  3655.     Easy . es_GadgetFormat    = LocaleString(MSG_GLOBAL_CONTINUE_TXT);
  3656.  
  3657.     if(Args[ARG_REQUESTNOTIFY_TITLE])
  3658.         Easy . es_Title    = Args[ARG_REQUESTNOTIFY_TITLE];
  3659.     else
  3660.         Easy . es_Title    = LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  3661.  
  3662.     BlockWindows();
  3663.  
  3664.     EasyRequestArgs(Window,&Easy,&IDCMP,NULL);
  3665.  
  3666.     ReleaseWindows();
  3667.  
  3668.     return(NULL);
  3669. }
  3670.  
  3671. STRPTR
  3672. RexxRequestNumber(struct RexxPkt *Pkt)
  3673. {
  3674.     enum    {    ARG_REQUESTNUMBER_DEFAULT,ARG_REQUESTNUMBER_PROMPT };
  3675.  
  3676.     UBYTE DummyBuffer[256];
  3677.  
  3678.     if(Args[ARG_REQUESTNUMBER_DEFAULT])
  3679.         SPrintf(DummyBuffer,"%ld",*(LONG *)Args[ARG_REQUESTNUMBER_DEFAULT]);
  3680.     else
  3681.         DummyBuffer[0] = 0;
  3682.  
  3683.     BlockWindows();
  3684.  
  3685.     if(GetString(FALSE,FALSE,255,Args[ARG_REQUESTNUMBER_PROMPT],DummyBuffer))
  3686.     {
  3687.         STRPTR Index = DummyBuffer;
  3688.  
  3689.         while(*Index == ' ' || *Index == '\t')
  3690.             Index++;
  3691.  
  3692.         if(*Index)
  3693.         {
  3694.             LONG Value;
  3695.  
  3696.             if(StrToLong(DummyBuffer,&Value) == -1)
  3697.             {
  3698.                 Results[0] = RC_ERROR;
  3699.                 Results[1] = ERROR_BAD_NUMBER;
  3700.             }
  3701.             else
  3702.             {
  3703.                 ReleaseWindows();
  3704.  
  3705.                 SPrintf(DummyBuffer,"%ld",Value);
  3706.  
  3707.                 return(CreateResult(DummyBuffer,Results));
  3708.             }
  3709.         }
  3710.         else
  3711.             Results[0] = RC_WARN;
  3712.     }
  3713.     else
  3714.         Results[0] = RC_WARN;
  3715.  
  3716.     ReleaseWindows();
  3717.  
  3718.     return(NULL);
  3719. }
  3720.  
  3721. STRPTR
  3722. RexxRequestResponse(struct RexxPkt *Pkt)
  3723. {
  3724.     enum    {    ARG_REQUESTRESPONSE_TITLE,ARG_REQUESTRESPONSE_OPTIONS,
  3725.             ARG_REQUESTRESPONSE_PROMPT };
  3726.  
  3727.     struct EasyStruct    Easy;
  3728.     ULONG            IDCMP = NULL;
  3729.     WORD            Result;
  3730.  
  3731.     Easy . es_StructSize    = sizeof(struct EasyStruct);
  3732.     Easy . es_Flags        = NULL;
  3733.     Easy . es_TextFormat    = Args[ARG_REQUESTRESPONSE_PROMPT];
  3734.  
  3735.     if(Args[ARG_REQUESTRESPONSE_OPTIONS])
  3736.         Easy . es_GadgetFormat = Args[ARG_REQUESTRESPONSE_OPTIONS];
  3737.     else
  3738.         Easy . es_GadgetFormat = LocaleString(MSG_GLOBAL_YES_NO_TXT);
  3739.  
  3740.     if(Args[ARG_REQUESTRESPONSE_TITLE])
  3741.         Easy . es_Title    = Args[ARG_REQUESTRESPONSE_TITLE];
  3742.     else
  3743.         Easy . es_Title    = LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  3744.  
  3745.     BlockWindows();
  3746.  
  3747.     Result = EasyRequestArgs(Window,&Easy,&IDCMP,NULL);
  3748.  
  3749.     ReleaseWindows();
  3750.  
  3751.     if(Result)
  3752.     {
  3753.         UBYTE DummyBuffer[20];
  3754.  
  3755.         SPrintf(DummyBuffer,"%ld",Result);
  3756.  
  3757.         return(CreateResult(DummyBuffer,Results));
  3758.     }
  3759.     else
  3760.     {
  3761.         Results[0] = RC_WARN;
  3762.  
  3763.         return(NULL);
  3764.     }
  3765. }
  3766.  
  3767. STRPTR
  3768. RexxRequestString(struct RexxPkt *Pkt)
  3769. {
  3770.     enum    {    ARG_REQUESTSTRING_SECRET,ARG_REQUESTSTRING_DEFAULT,ARG_REQUESTSTRING_PROMPT };
  3771.  
  3772.     UBYTE DummyBuffer[256];
  3773.  
  3774.     if(Args[ARG_REQUESTSTRING_DEFAULT])
  3775.         strcpy(DummyBuffer,Args[ARG_REQUESTSTRING_DEFAULT]);
  3776.     else
  3777.         DummyBuffer[0] = 0;
  3778.  
  3779.     BlockWindows();
  3780.  
  3781.     if(GetString(FALSE,Args[ARG_REQUESTSTRING_SECRET] != NULL,255,Args[ARG_REQUESTSTRING_PROMPT],DummyBuffer))
  3782.     {
  3783.         ReleaseWindows();
  3784.  
  3785.         return(CreateResult(DummyBuffer,Results));
  3786.     }
  3787.     else
  3788.         Results[0] = RC_WARN;
  3789.  
  3790.     ReleaseWindows();
  3791.  
  3792.     return(NULL);
  3793. }
  3794.  
  3795. STRPTR
  3796. RexxResetScreen(struct RexxPkt *Pkt)
  3797. {
  3798.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3799.         XEmulatorResetConsole(XEM_IO);
  3800.     else
  3801.     {
  3802.         FreeMarker();
  3803.  
  3804.         ObtainSemaphore(&TerminalSemaphore);
  3805.  
  3806.         ClearCursor();
  3807.  
  3808.         Reset();
  3809.  
  3810.         DrawCursor();
  3811.  
  3812.         ReleaseSemaphore(&TerminalSemaphore);
  3813.     }
  3814.  
  3815.     return(NULL);
  3816. }
  3817.  
  3818. STRPTR
  3819. RexxResetStyles(struct RexxPkt *Pkt)
  3820. {
  3821.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3822.         XEmulatorResetTextStyles(XEM_IO);
  3823.     else
  3824.     {
  3825.         DropMarker();
  3826.  
  3827.         ConBypass("\033[0m",-1);
  3828.  
  3829.         ObtainSemaphore(&TerminalSemaphore);
  3830.  
  3831.         ClearCursor();
  3832.  
  3833.         Config -> EmulationConfig -> FontScale = SCALE_NORMAL;
  3834.  
  3835.         FgPen = GetPenIndex(SafeTextPen);
  3836.         BgPen = 0;
  3837.  
  3838.         if(ReadAPen(RPort) != MappedPens[0][FgPen])
  3839.             SetAPen(RPort,MappedPens[0][FgPen]);
  3840.  
  3841.         if(ReadBPen(RPort) != MappedPens[0][BgPen])
  3842.             SetBPen(RPort,MappedPens[0][BgPen]);
  3843.  
  3844.         SetWrMsk(RPort,DepthMask);
  3845.  
  3846.         ConFontScaleUpdate();
  3847.  
  3848.         DrawCursor();
  3849.  
  3850.         ReleaseSemaphore(&TerminalSemaphore);
  3851.     }
  3852.  
  3853.     return(NULL);
  3854. }
  3855.  
  3856. STRPTR
  3857. RexxResetText(struct RexxPkt *Pkt)
  3858. {
  3859.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3860.         XEmulatorResetCharset(XEM_IO);
  3861.     else
  3862.     {
  3863.         DropMarker();
  3864.  
  3865.         CurrentFont = TextFont;
  3866.  
  3867.         SetFont(RPort,CurrentFont);
  3868.  
  3869.         ConOutputUpdate();
  3870.     }
  3871.  
  3872.     return(NULL);
  3873. }
  3874.  
  3875. STRPTR
  3876. RexxResetTimer(struct RexxPkt *Pkt)
  3877. {
  3878.     Forbid();
  3879.  
  3880.     if(StatusProcess)
  3881.         Signal(StatusProcess,SIG_RESETTIME);
  3882.  
  3883.     Permit();
  3884.  
  3885.     return(NULL);
  3886. }
  3887.  
  3888. STRPTR
  3889. RexxSaveAs(struct RexxPkt *Pkt)
  3890. {
  3891.     enum    {    ARG_SAVEAS_NAME,ARG_SAVEAS_FROM };
  3892.  
  3893.     WORD Index = ToConfig(Args[ARG_SAVEAS_FROM]);
  3894.  
  3895.     if(Index == -1)
  3896.     {
  3897.         Results[0] = RC_ERROR;
  3898.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  3899.     }
  3900.     else
  3901.     {
  3902.         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  3903.         STRPTR    FileName;
  3904.  
  3905.         if(Args[ARG_SAVEAS_NAME])
  3906.             FileName = Args[ARG_SAVEAS_NAME];
  3907.         else
  3908.         {
  3909.             STRPTR             Title;
  3910.             struct FileRequester    *FileRequest;
  3911.  
  3912.             FileName = NULL;
  3913.  
  3914.             switch(Index)
  3915.             {
  3916.                 case DATATYPE_TRANSLATIONS:
  3917.  
  3918.                     Title = LocaleString(MSG_TRANSLATIONPANEL_SAVE_TRANSLATION_TABLES_TXT);
  3919.                     break;
  3920.  
  3921.                 case DATATYPE_FUNCTIONKEYS:
  3922.  
  3923.                     Title = LocaleString(MSG_MACROPANEL_SAVE_MACRO_KEYS_TXT);
  3924.                     break;
  3925.  
  3926.                 case DATATYPE_CURSORKEYS:
  3927.  
  3928.                     Title = LocaleString(MSG_CURSORPANEL_SAVE_CURSOR_KEYS_TXT);
  3929.                     break;
  3930.  
  3931.                 case DATATYPE_FASTMACROS:
  3932.  
  3933.                     Title = LocaleString(MSG_FASTMACROPANEL_SAVE_FAST_MACRO_SETTINGS_TXT);
  3934.                     break;
  3935.  
  3936.                 case DATATYPE_HOTKEYS:
  3937.  
  3938.                     Title = LocaleString(MSG_HOTKEYPANEL_SAVE_HOTKEYS_TXT);
  3939.                     break;
  3940.  
  3941.                 case DATATYPE_SPEECH:
  3942.  
  3943.                     Title = LocaleString(MSG_SPEECHPANEL_SAVE_SPEECH_SETTINGS_TXT);
  3944.                     break;
  3945.  
  3946.                 case DATATYPE_SOUND:
  3947.  
  3948.                     Title = LocaleString(MSG_SOUNDPANEL_SAVE_SOUNDS_TXT);
  3949.                     break;
  3950.  
  3951.                 case DATATYPE_BUFFER:
  3952.  
  3953.                     Title = LocaleString(MSG_TERMMAIN_SAVE_BUFFER_TXT);
  3954.                     break;
  3955.  
  3956.                 case DATATYPE_CONFIGURATION:
  3957.  
  3958.                     Title = LocaleString(MSG_TERMMAIN_SAVE_PREFERENCES_AS_TXT);
  3959.                     break;
  3960.  
  3961.                 case DATATYPE_PHONEBOOK:
  3962.  
  3963.                     Title = LocaleString(MSG_PHONEPANEL_SAVE_PHONEBOOK_TXT);
  3964.                     break;
  3965.  
  3966.                 case DATATYPE_SCREENTEXT:
  3967.  
  3968.                     Title = LocaleString(MSG_TERMMAIN_SAVE_SCREEN_ASCII_TXT);
  3969.                     break;
  3970.  
  3971.                 case DATATYPE_SCREENIMAGE:
  3972.  
  3973.                     Title = LocaleString(MSG_TERMMAIN_SAVE_SCREEN_IFF_TXT);
  3974.                     break;
  3975.             }
  3976.  
  3977.             BlockWindows();
  3978.  
  3979.             if(FileRequest = GetFile(Window,Title,"","",DummyBuffer,NULL,TRUE,FALSE,FALSE,NULL,TRUE))
  3980.             {
  3981.                 FileName = DummyBuffer;
  3982.  
  3983.                 FreeAslRequest(FileRequest);
  3984.             }
  3985.  
  3986.             ReleaseWindows();
  3987.         }
  3988.  
  3989.         if(FileName)
  3990.         {
  3991.             switch(Index)
  3992.             {
  3993.                 case DATATYPE_TRANSLATIONS:
  3994.                 {
  3995.                     if(SendTable && ReceiveTable)
  3996.                     {
  3997.                         if(!SaveTranslationTables(FileName,SendTable,ReceiveTable))
  3998.                         {
  3999.                             Results[0] = RC_ERROR;
  4000.                             Results[1] = IoErr();
  4001.                         }
  4002.                         else
  4003.                         {
  4004.                             strcpy(LastTranslation,FileName);
  4005.  
  4006.                             TranslationChanged = FALSE;
  4007.                         }
  4008.                     }
  4009.                     else
  4010.                         Results[0] = RC_WARN;
  4011.                 }
  4012.  
  4013.                 break;
  4014.  
  4015.                 case DATATYPE_FUNCTIONKEYS:
  4016.                 {
  4017.                     if(!WriteIFFData(FileName,MacroKeys,sizeof(struct MacroKeys),ID_KEYS))
  4018.                     {
  4019.                         Results[0] = RC_ERROR;
  4020.                         Results[1] = IoErr();
  4021.                     }
  4022.                     else
  4023.                     {
  4024.                         strcpy(LastMacros,FileName);
  4025.  
  4026.                         MacroChanged = FALSE;
  4027.                     }
  4028.                 }
  4029.  
  4030.                 break;
  4031.  
  4032.                 case DATATYPE_CURSORKEYS:
  4033.                 {
  4034.                     if(!WriteIFFData(FileName,CursorKeys,sizeof(struct CursorKeys),ID_KEYS))
  4035.                     {
  4036.                         Results[0] = RC_ERROR;
  4037.                         Results[1] = IoErr();
  4038.                     }
  4039.                     else
  4040.                     {
  4041.                         strcpy(LastCursorKeys,FileName);
  4042.  
  4043.                         CursorKeysChanged = FALSE;
  4044.                     }
  4045.                 }
  4046.  
  4047.                 break;
  4048.  
  4049.                 case DATATYPE_FASTMACROS:
  4050.                 {
  4051.                     if(!SaveFastMacros(FileName,&FastMacroList))
  4052.                     {
  4053.                         Results[0] = RC_ERROR;
  4054.                         Results[1] = IoErr();
  4055.                     }
  4056.                     else
  4057.                     {
  4058.                         strcpy(LastFastMacros,FileName);
  4059.  
  4060.                         FastMacrosChanged = FALSE;
  4061.                     }
  4062.                 }
  4063.  
  4064.                 break;
  4065.  
  4066.                 case DATATYPE_HOTKEYS:
  4067.                 {
  4068.                     if(!WriteIFFData(FileName,&Hotkeys,sizeof(struct Hotkeys),ID_HOTK))
  4069.                     {
  4070.                         Results[0] = RC_ERROR;
  4071.                         Results[1] = IoErr();
  4072.                     }
  4073.                     else
  4074.                     {
  4075.                         strcpy(LastKeys,FileName);
  4076.  
  4077.                         HotkeysChanged = FALSE;
  4078.                     }
  4079.                 }
  4080.  
  4081.                 break;
  4082.  
  4083.                 case DATATYPE_SPEECH:
  4084.                 {
  4085.                     if(!WriteIFFData(FileName,&SpeechConfig,sizeof(struct SpeechConfig),ID_SPEK))
  4086.                     {
  4087.                         Results[0] = RC_ERROR;
  4088.                         Results[1] = IoErr();
  4089.                     }
  4090.                     else
  4091.                     {
  4092.                         strcpy(LastSpeech,FileName);
  4093.  
  4094.                         SpeechChanged = FALSE;
  4095.                     }
  4096.                 }
  4097.  
  4098.                 break;
  4099.  
  4100.                 case DATATYPE_SOUND:
  4101.                 {
  4102.                     if(!WriteIFFData(FileName,&SoundConfig,sizeof(struct SoundConfig),ID_SOUN))
  4103.                     {
  4104.                         Results[0] = RC_ERROR;
  4105.                         Results[1] = IoErr();
  4106.                     }
  4107.                     else
  4108.                     {
  4109.                         strcpy(LastSound,FileName);
  4110.  
  4111.                         SoundChanged = FALSE;
  4112.                     }
  4113.                 }
  4114.  
  4115.                 break;
  4116.  
  4117.                 case DATATYPE_BUFFER:
  4118.                 {
  4119.                     if(BufferLines && Lines)
  4120.                     {
  4121.                         BPTR SomeFile;
  4122.  
  4123.                         if(GetFileSize(FileName))
  4124.                         {
  4125.                             if(SomeFile = Open(FileName,MODE_READWRITE))
  4126.                             {
  4127.                                 if(Seek(SomeFile,0,OFFSET_END) == -1)
  4128.                                 {
  4129.                                     Close(SomeFile);
  4130.  
  4131.                                     SomeFile = NULL;
  4132.  
  4133.                                     SetIoErr(ERROR_SEEK_ERROR);
  4134.                                 }
  4135.                             }
  4136.                         }
  4137.                         else
  4138.                             SomeFile = Open(FileName,MODE_NEWFILE);
  4139.  
  4140.                         if(SomeFile)
  4141.                         {
  4142.                             LONG i,Len;
  4143.  
  4144.                                 /* Obtain the semaphore required
  4145.                                  * to gain access to the line buffer
  4146.                                  */
  4147.  
  4148.                             ObtainSemaphore(BufferSemaphore);
  4149.  
  4150.                             for(i = 0 ; i < Lines ; i++)
  4151.                             {
  4152.                                 Len = BufferLines[i][-1];
  4153.  
  4154.                                 if(Len)
  4155.                                 {
  4156.                                     if(FWrite(SomeFile,BufferLines[i],Len,1) != 1)
  4157.                                     {
  4158.                                         Results[0] = RC_ERROR;
  4159.                                         Results[1] = IoErr();
  4160.  
  4161.                                         break;
  4162.                                     }
  4163.                                 }
  4164.  
  4165.                                 if(FPrintf(SomeFile,"\n") < 1)
  4166.                                 {
  4167.                                     Results[0] = RC_ERROR;
  4168.                                     Results[1] = IoErr();
  4169.  
  4170.                                     break;
  4171.                                 }
  4172.                             }
  4173.  
  4174.                             ReleaseSemaphore(BufferSemaphore);
  4175.  
  4176.                             Close(SomeFile);
  4177.  
  4178.                             AddProtection(FileName,FIBF_EXECUTE);
  4179.  
  4180.                             if(Config -> MiscConfig -> CreateIcons)
  4181.                                 AddIcon(FileName,FILETYPE_TEXT,TRUE);
  4182.  
  4183.                             BufferChanged = FALSE;
  4184.                         }
  4185.                         else
  4186.                         {
  4187.                             Results[0] = RC_ERROR;
  4188.                             Results[1] = IoErr();
  4189.                         }
  4190.                     }
  4191.                     else
  4192.                     {
  4193.                         Results[0] = RC_ERROR;
  4194.                         Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  4195.                     }
  4196.                 }
  4197.  
  4198.                 break;
  4199.  
  4200.                 case DATATYPE_CONFIGURATION:
  4201.                 {
  4202.                     if(!WriteConfig(FileName,Config))
  4203.                     {
  4204.                         Results[0] = RC_ERROR;
  4205.                         Results[1] = IoErr();
  4206.                     }
  4207.                     else
  4208.                     {
  4209.                         strcpy(LastConfig,FileName);
  4210.  
  4211.                         ConfigChanged = FALSE;
  4212.                     }
  4213.                 }
  4214.  
  4215.                 break;
  4216.  
  4217.                 case DATATYPE_PHONEBOOK:
  4218.                 {
  4219.                     if(!SavePhonebook(FileName))
  4220.                     {
  4221.                         Results[0] = RC_ERROR;
  4222.                         Results[1] = IoErr();
  4223.                     }
  4224.                     else
  4225.                     {
  4226.                         strcpy(LastPhone,FileName);
  4227.  
  4228.                         PhonebookChanged = FALSE;
  4229.                     }
  4230.                 }
  4231.  
  4232.                 break;
  4233.  
  4234.                 case DATATYPE_SCREENTEXT:
  4235.                 {
  4236.                     if(RasterEnabled)
  4237.                     {
  4238.                         BPTR SomeFile;
  4239.  
  4240.                         if(GetFileSize(FileName))
  4241.                         {
  4242.                             if(SomeFile = Open(FileName,MODE_READWRITE))
  4243.                             {
  4244.                                 if(Seek(SomeFile,0,OFFSET_END) == -1)
  4245.                                 {
  4246.                                     Close(SomeFile);
  4247.  
  4248.                                     SomeFile = NULL;
  4249.  
  4250.                                     SetIoErr(ERROR_SEEK_ERROR);
  4251.                                 }
  4252.                             }
  4253.                         }
  4254.                         else
  4255.                             SomeFile = Open(FileName,MODE_NEWFILE);
  4256.  
  4257.                         if(SomeFile)
  4258.                         {
  4259.                             LONG     i,j;
  4260.                             UBYTE    *Buffer;
  4261.  
  4262.                             for(i = 0 ; i < RasterHeight ; i++)
  4263.                             {
  4264.                                 Buffer = &Raster[i * RasterWidth];
  4265.  
  4266.                                 j = LastColumn;
  4267.  
  4268.                                 while(j >= 0 && Buffer[j] == ' ')
  4269.                                     j--;
  4270.  
  4271.                                 if(j >= 0)
  4272.                                 {
  4273.                                     if(!FWrite(SomeFile,Buffer,j + 1,1))
  4274.                                     {
  4275.                                         Results[0] = RC_ERROR;
  4276.                                         Results[1] = IoErr();
  4277.  
  4278.                                         break;
  4279.                                     }
  4280.                                 }
  4281.  
  4282.                                 if(!FWrite(SomeFile,"\n",1,1))
  4283.                                 {
  4284.                                     Results[0] = RC_ERROR;
  4285.                                     Results[1] = IoErr();
  4286.  
  4287.                                     break;
  4288.                                 }
  4289.                             }
  4290.  
  4291.                             Close(SomeFile);
  4292.  
  4293.                             AddProtection(FileName,FIBF_EXECUTE);
  4294.  
  4295.                             if(Config -> MiscConfig -> CreateIcons)
  4296.                                 AddIcon(FileName,FILETYPE_TEXT,TRUE);
  4297.                         }
  4298.                         else
  4299.                         {
  4300.                             Results[0] = RC_ERROR;
  4301.                             Results[1] = IoErr();
  4302.                         }
  4303.                     }
  4304.                     else
  4305.                     {
  4306.                         Results[0] = RC_ERROR;
  4307.                         Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  4308.                     }
  4309.                 }
  4310.  
  4311.                 break;
  4312.  
  4313.                 case DATATYPE_SCREENIMAGE:
  4314.                 {
  4315.                     if(!SaveWindow(FileName,Window))
  4316.                     {
  4317.                         Results[0] = RC_ERROR;
  4318.                         Results[1] = IoErr();
  4319.                     }
  4320.                 }
  4321.  
  4322.                 break;
  4323.             }
  4324.         }
  4325.         else
  4326.             Results[0] = RC_WARN;
  4327.     }
  4328.  
  4329.     return(NULL);
  4330. }
  4331.  
  4332. STRPTR
  4333. RexxSave(struct RexxPkt *Pkt)
  4334. {
  4335.     enum    {    ARG_SAVE_FROM };
  4336.  
  4337.     Args[1] = Args[ARG_SAVE_FROM];
  4338.     Args[0] = NULL;
  4339.  
  4340.     return(RexxSaveAs(Pkt));
  4341. }
  4342.  
  4343. STRPTR
  4344. RexxSelect(struct RexxPkt *Pkt)
  4345. {
  4346.     enum    {    ARG_SELECT_NAME,ARG_SELECT_FROM,ARG_SELECT_NEXT,ARG_SELECT_PREVIOUS,
  4347.             ARG_SELECT_TOP,ARG_SELECT_BOTTOM };
  4348.  
  4349.     WORD Index;
  4350.  
  4351.     if((Index = ToList(Args[ARG_SELECT_FROM])) == -1)
  4352.     {
  4353.         Results[0] = RC_ERROR;
  4354.         Results[1] = TERMERROR_UNKNOWN_LIST;
  4355.     }
  4356.     else
  4357.     {
  4358.         if(Args[ARG_SELECT_NAME] && Index == GLIST_DIAL)
  4359.         {
  4360.             Results[0] = RC_ERROR;
  4361.             Results[1] = TERMERROR_DATA_TYPES_INCOMPATIBLE;
  4362.         }
  4363.         else
  4364.         {
  4365.             struct GenericList *List;
  4366.  
  4367.             List = GenericListTable[Index];
  4368.  
  4369.             if(Args[ARG_SELECT_NAME])
  4370.             {
  4371.                 STRPTR Buffer;
  4372.  
  4373.                 if(Buffer = CreateMatchBuffer(Args[ARG_SELECT_NAME]))
  4374.                 {
  4375.                     struct Node *Node,*NextNode;
  4376.  
  4377.                     ObtainSemaphore(&List -> ListSemaphore);
  4378.  
  4379.                     Node = (struct Node *)List -> ListHeader . mlh_Head;
  4380.  
  4381.                     while(NextNode = Node -> ln_Succ)
  4382.                     {
  4383.                         if(MatchBuffer(Buffer,Node -> ln_Name))
  4384.                         {
  4385.                             List -> ListNode = Node;
  4386.  
  4387.                             Node = NULL;
  4388.  
  4389.                             break;
  4390.                         }
  4391.  
  4392.                         Node = NextNode;
  4393.                     }
  4394.  
  4395.                     if(Node)
  4396.                         Results[0] = RC_WARN;
  4397.  
  4398.                     ReleaseSemaphore(&List -> ListSemaphore);
  4399.  
  4400.                     DeleteMatchBuffer(Buffer);
  4401.                 }
  4402.                 else
  4403.                 {
  4404.                     Results[0] = RC_ERROR;
  4405.                     Results[1] = ERROR_NO_FREE_STORE;
  4406.                 }
  4407.             }
  4408.             else
  4409.             {
  4410.                 if(Args[ARG_SELECT_NEXT])
  4411.                 {
  4412.                     if(!NextGenericListNode(List))
  4413.                     {
  4414.                         Results[0] = RC_WARN;
  4415.  
  4416.                         return(NULL);
  4417.                     }
  4418.                 }
  4419.  
  4420.                 if(Args[ARG_SELECT_PREVIOUS])
  4421.                 {
  4422.                     if(!PrevGenericListNode(List))
  4423.                     {
  4424.                         Results[0] = RC_WARN;
  4425.  
  4426.                         return(NULL);
  4427.                     }
  4428.                 }
  4429.  
  4430.                 if(Args[ARG_SELECT_TOP])
  4431.                 {
  4432.                     if(!FirstGenericListNode(List))
  4433.                     {
  4434.                         Results[0] = RC_WARN;
  4435.  
  4436.                         return(NULL);
  4437.                     }
  4438.                 }
  4439.  
  4440.                 if(Args[ARG_SELECT_BOTTOM])
  4441.                 {
  4442.                     if(!LastGenericListNode(List))
  4443.                     {
  4444.                         Results[0] = RC_WARN;
  4445.  
  4446.                         return(NULL);
  4447.                     }
  4448.                 }
  4449.             }
  4450.  
  4451.             ObtainSemaphore(&List -> ListSemaphore);
  4452.  
  4453.             if(List -> ListNode)
  4454.             {
  4455.                 if(Index != GLIST_DIAL)
  4456.                 {
  4457.                     struct Node    *Node = (struct Node *)List -> ListNode;
  4458.                     STRPTR         Result;
  4459.  
  4460.                     Result = CreateResult(Node -> ln_Name,Results);
  4461.  
  4462.                     ReleaseSemaphore(&List -> ListSemaphore);
  4463.  
  4464.                     return(Result);
  4465.                 }
  4466.             }
  4467.             else
  4468.                 Results[0] = RC_WARN;
  4469.  
  4470.             ReleaseSemaphore(&List -> ListSemaphore);
  4471.         }
  4472.     }
  4473.  
  4474.     return(NULL);
  4475. }
  4476.  
  4477. STRPTR
  4478. RexxSend(struct RexxPkt *Pkt)
  4479. {
  4480.     enum    {    ARG_SEND_NOECHO,ARG_SEND_LOCAL,ARG_SEND_BYTE,ARG_SEND_TEXT };
  4481.  
  4482.     if(Args[ARG_SEND_LOCAL])
  4483.     {
  4484.         if(!Args[ARG_SEND_NOECHO])
  4485.         {
  4486.             if(Marking)
  4487.                 DropMarker();
  4488.  
  4489.             if(Args[ARG_SEND_TEXT])
  4490.                 ConsoleCommand(Args[ARG_SEND_TEXT]);
  4491.             else
  4492.             {
  4493.                 UBYTE Byte = *(LONG *)Args[ARG_SEND_BYTE];
  4494.  
  4495.                 ConProcess(&Byte,1);
  4496.             }
  4497.         }
  4498.     }
  4499.     else
  4500.     {
  4501.         if(Args[ARG_SEND_NOECHO])
  4502.             Quiet = TRUE;
  4503.  
  4504.         if(Args[ARG_SEND_TEXT])
  4505.             SerialCommand(Args[ARG_SEND_TEXT]);
  4506.         else
  4507.         {
  4508.             UBYTE Byte = *(LONG *)Args[ARG_SEND_BYTE];
  4509.  
  4510.             SerWrite(&Byte,1);
  4511.         }
  4512.  
  4513.         Quiet = FALSE;
  4514.     }
  4515.  
  4516.     return(NULL);
  4517. }
  4518.  
  4519. STRPTR
  4520. RexxSendBreak(struct RexxPkt *Pkt)
  4521. {
  4522.     if(WriteRequest)
  4523.         SendBreak();
  4524.     else
  4525.         Results[0] = RC_WARN;
  4526.  
  4527.     return(NULL);
  4528. }
  4529.  
  4530. STRPTR
  4531. RexxSendFile(struct RexxPkt *Pkt)
  4532. {
  4533.     enum    {    ARG_SENDFILE_MODE,ARG_SENDFILE_NAMES };
  4534.  
  4535.     WORD Mode = TRANSFER_BINARY;
  4536.  
  4537.     if(Args[ARG_SENDFILE_MODE])
  4538.         Mode = ToMode(Args[ARG_SENDFILE_MODE]);
  4539.  
  4540.     if(Mode == -1)
  4541.     {
  4542.         Results[0] = RC_ERROR;
  4543.         Results[1] = ERROR_ACTION_NOT_KNOWN;
  4544.     }
  4545.     else
  4546.     {
  4547.         struct FileTransferInfo    *Info;
  4548.         LONG             FilesFound = 0;
  4549.  
  4550.         if(Info = AllocFileTransferInfo())
  4551.         {
  4552.             struct GenericList *List = GenericListTable[GLIST_UPLOAD];
  4553.  
  4554.             if(Args[ARG_SENDFILE_NAMES])
  4555.             {
  4556.                 struct FileInfoBlock *FileInfo;
  4557.  
  4558.                 if(FileInfo = (struct FileInfoBlock *)AllocDosObject(DOS_FIB,TAG_DONE))
  4559.                 {
  4560.                     STRPTR    *Names = (STRPTR *)Args[ARG_SENDFILE_NAMES];
  4561.                     BPTR     FileLock,NewDir,OldDir;
  4562.  
  4563.                     NewDir = NULL;
  4564.  
  4565.                     switch(Mode)
  4566.                     {
  4567.                         case TRANSFER_BINARY:
  4568.  
  4569.                             if(Config -> PathConfig -> BinaryUploadPath[0])
  4570.                                 NewDir = Lock(Config -> PathConfig -> BinaryUploadPath,ACCESS_READ);
  4571.  
  4572.                             break;
  4573.  
  4574.                         case TRANSFER_TEXT:
  4575.  
  4576.                             if(Config -> PathConfig -> TextUploadPath[0])
  4577.                                 NewDir = Lock(Config -> PathConfig -> TextUploadPath,ACCESS_READ);
  4578.  
  4579.                             break;
  4580.  
  4581.                         case TRANSFER_ASCII:
  4582.  
  4583.                             if(Config -> PathConfig -> ASCIIUploadPath[0])
  4584.                                 NewDir = Lock(Config -> PathConfig -> ASCIIUploadPath,ACCESS_READ);
  4585.  
  4586.                             break;
  4587.                     }
  4588.  
  4589.                     if(NewDir)
  4590.                         OldDir = CurrentDir(NewDir);
  4591.                     else
  4592.                         OldDir = NULL;
  4593.  
  4594.                     while(*Names && Results[0] == RC_OK)
  4595.                     {
  4596.                         if(FileLock = Lock(*Names,ACCESS_READ))
  4597.                         {
  4598.                             if(Examine(FileLock,FileInfo))
  4599.                             {
  4600.                                 if(FileInfo -> fib_DirEntryType < 0)
  4601.                                 {
  4602.                                     if(NameFromLock(FileLock,SharedBuffer,512))
  4603.                                     {
  4604.                                         if(AddFileTransferNode(Info,SharedBuffer,FileInfo -> fib_Size))
  4605.                                             FilesFound++;
  4606.                                         else
  4607.                                         {
  4608.                                             Results[0] = RC_ERROR;
  4609.                                             Results[1] = ERROR_NO_FREE_STORE;
  4610.                                         }
  4611.                                     }
  4612.                                     else
  4613.                                     {
  4614.                                         Results[0] = RC_ERROR;
  4615.                                         Results[1] = IoErr();
  4616.                                     }
  4617.                                 }
  4618.                                 else
  4619.                                 {
  4620.                                     Results[0] = RC_ERROR;
  4621.                                     Results[1] = ERROR_OBJECT_WRONG_TYPE;
  4622.                                 }
  4623.                             }
  4624.                             else
  4625.                             {
  4626.                                 Results[0] = RC_ERROR;
  4627.                                 Results[1] = IoErr();
  4628.                             }
  4629.  
  4630.                             UnLock(FileLock);
  4631.                         }
  4632.                         else
  4633.                         {
  4634.                             Results[0] = RC_ERROR;
  4635.                             Results[1] = IoErr();
  4636.                         }
  4637.  
  4638.                         Names++;
  4639.                     }
  4640.  
  4641.                     if(OldDir)
  4642.                         CurrentDir(OldDir);
  4643.  
  4644.                     if(NewDir)
  4645.                         UnLock(NewDir);
  4646.  
  4647.                     FreeDosObject(DOS_FIB,FileInfo);
  4648.                 }
  4649.                 else
  4650.                 {
  4651.                     Results[0] = RC_ERROR;
  4652.                     Results[1] = ERROR_NO_FREE_STORE;
  4653.                 }
  4654.             }
  4655.  
  4656.             ObtainSemaphore(&List -> ListSemaphore);
  4657.  
  4658.             if(List -> ListHeader . mlh_Head -> mln_Succ)
  4659.             {
  4660.                 struct Node        *Node = (struct Node *)List -> ListHeader . mlh_Head;
  4661.                 struct FileInfoBlock    *FileInfo;
  4662.                 BPTR             NewDir,OldDir;
  4663.  
  4664.                 NewDir = NULL;
  4665.  
  4666.                 switch(Mode)
  4667.                 {
  4668.                     case TRANSFER_BINARY:
  4669.  
  4670.                         if(Config -> PathConfig -> BinaryUploadPath[0])
  4671.                             NewDir = Lock(Config -> PathConfig -> BinaryUploadPath,ACCESS_READ);
  4672.  
  4673.                         break;
  4674.  
  4675.                     case TRANSFER_TEXT:
  4676.  
  4677.                         if(Config -> PathConfig -> TextUploadPath[0])
  4678.                             NewDir = Lock(Config -> PathConfig -> TextUploadPath,ACCESS_READ);
  4679.  
  4680.                         break;
  4681.  
  4682.                     case TRANSFER_ASCII:
  4683.  
  4684.                         if(Config -> PathConfig -> ASCIIUploadPath[0])
  4685.                             NewDir = Lock(Config -> PathConfig -> ASCIIUploadPath,ACCESS_READ);
  4686.  
  4687.                         break;
  4688.                 }
  4689.  
  4690.                 if(NewDir)
  4691.                     OldDir = CurrentDir(NewDir);
  4692.                 else
  4693.                     OldDir = NULL;
  4694.  
  4695.                 if(FileInfo = (struct FileInfoBlock *)AllocDosObject(DOS_FIB,TAG_DONE))
  4696.                 {
  4697.                     BPTR FileLock;
  4698.  
  4699.                     while(Node -> ln_Succ && Results[0] == RC_OK)
  4700.                     {
  4701.                         if(FileLock = Lock(Node -> ln_Name,ACCESS_READ))
  4702.                         {
  4703.                             if(Examine(FileLock,FileInfo))
  4704.                             {
  4705.                                 if(FileInfo -> fib_DirEntryType < 0)
  4706.                                 {
  4707.                                     if(NameFromLock(FileLock,SharedBuffer,512))
  4708.                                     {
  4709.                                         if(AddFileTransferNode(Info,SharedBuffer,FileInfo -> fib_Size))
  4710.                                             FilesFound++;
  4711.                                         else
  4712.                                         {
  4713.                                             Results[0] = RC_ERROR;
  4714.                                             Results[1] = ERROR_NO_FREE_STORE;
  4715.                                         }
  4716.                                     }
  4717.                                     else
  4718.                                     {
  4719.                                         Results[0] = RC_ERROR;
  4720.                                         Results[1] = IoErr();
  4721.                                     }
  4722.                                 }
  4723.                                 else
  4724.                                 {
  4725.                                     Results[0] = RC_ERROR;
  4726.                                     Results[1] = ERROR_OBJECT_WRONG_TYPE;
  4727.                                 }
  4728.                             }
  4729.                             else
  4730.                             {
  4731.                                 Results[0] = RC_ERROR;
  4732.                                 Results[1] = IoErr();
  4733.                             }
  4734.  
  4735.                             UnLock(FileLock);
  4736.                         }
  4737.                         else
  4738.                         {
  4739.                             Results[0] = RC_ERROR;
  4740.                             Results[1] = IoErr();
  4741.                         }
  4742.  
  4743.                         Node = Node -> ln_Succ;
  4744.                     }
  4745.  
  4746.                     if(OldDir)
  4747.                         CurrentDir(OldDir);
  4748.  
  4749.                     if(NewDir)
  4750.                         UnLock(NewDir);
  4751.  
  4752.                     FreeDosObject(DOS_FIB,FileInfo);
  4753.                 }
  4754.                 else
  4755.                 {
  4756.                     Results[0] = RC_ERROR;
  4757.                     Results[1] = ERROR_NO_FREE_STORE;
  4758.                 }
  4759.             }
  4760.  
  4761.             ReleaseSemaphore(&List -> ListSemaphore);
  4762.  
  4763.             if(Results[0] == RC_OK)
  4764.             {
  4765.                 BlockWindows();
  4766.  
  4767.                 if(FilesFound)
  4768.                 {
  4769.                     SortFileTransferInfo(Info);
  4770.  
  4771.                     FileTransferInfo = Info;
  4772.                 }
  4773.  
  4774.                 switch(Mode)
  4775.                 {
  4776.                     case TRANSFER_ASCII:
  4777.  
  4778.                         if(ChangeProtocol(Config -> TransferConfig -> ASCIIUploadLibrary))
  4779.                         {
  4780.                             BinaryTransfer = FALSE;
  4781.  
  4782.                             if(FilesFound)
  4783.                                 StartXprSendFromList(TRANSFER_ASCII,FALSE);
  4784.                             else
  4785.                                 StartXprSend(TRANSFER_ASCII,FALSE);
  4786.  
  4787.                             BinaryTransfer = TRUE;
  4788.  
  4789.                             SerialCommand(Config -> CommandConfig -> UploadMacro);
  4790.                         }
  4791.                         else
  4792.                         {
  4793.                             Results[0] = RC_ERROR;
  4794.                             Results[1] = ERROR_NO_FREE_STORE;
  4795.                         }
  4796.  
  4797.                         ResetProtocol();
  4798.  
  4799.                         break;
  4800.  
  4801.                     case TRANSFER_TEXT:
  4802.  
  4803.                         if(ChangeProtocol(Config -> TransferConfig -> TextUploadLibrary))
  4804.                         {
  4805.                             BinaryTransfer = FALSE;
  4806.  
  4807.                             if(FilesFound)
  4808.                                 StartXprSendFromList(TRANSFER_TEXT,FALSE);
  4809.                             else
  4810.                                 StartXprSend(TRANSFER_TEXT,FALSE);
  4811.  
  4812.                             BinaryTransfer = TRUE;
  4813.  
  4814.                             SerialCommand(Config -> CommandConfig -> UploadMacro);
  4815.                         }
  4816.                         else
  4817.                         {
  4818.                             Results[0] = RC_ERROR;
  4819.                             Results[1] = ERROR_NO_FREE_STORE;
  4820.                         }
  4821.  
  4822.                         ResetProtocol();
  4823.  
  4824.                         break;
  4825.  
  4826.                     case TRANSFER_BINARY:
  4827.  
  4828.                         if(ChangeProtocol(Config -> TransferConfig -> BinaryUploadLibrary))
  4829.                         {
  4830.                             BinaryTransfer = TRUE;
  4831.  
  4832.                             if(FilesFound)
  4833.                                 StartXprSendFromList(TRANSFER_BINARY,FALSE);
  4834.                             else
  4835.                                 StartXprSend(TRANSFER_BINARY,FALSE);
  4836.  
  4837.                             SerialCommand(Config -> CommandConfig -> UploadMacro);
  4838.                         }
  4839.                         else
  4840.                         {
  4841.                             Results[0] = RC_ERROR;
  4842.                             Results[1] = ERROR_NO_FREE_STORE;
  4843.                         }
  4844.  
  4845.                         ResetProtocol();
  4846.  
  4847.                         break;
  4848.                 }
  4849.  
  4850.                 if(TransferFailed)
  4851.                     Results[0] = RC_ERROR;
  4852.  
  4853.                 if(TransferAborted)
  4854.                     Results[0] = RC_WARN;
  4855.  
  4856.                 ReleaseWindows();
  4857.             }
  4858.             else
  4859.                 FreeFileTransferInfo(Info);
  4860.         }
  4861.         else
  4862.         {
  4863.             Results[0] = RC_ERROR;
  4864.             Results[1] = ERROR_NO_FREE_STORE;
  4865.         }
  4866.     }
  4867.  
  4868.     return(NULL);
  4869. }
  4870.  
  4871. STRPTR
  4872. RexxSpeak(struct RexxPkt *Pkt)
  4873. {
  4874.     enum    {    ARG_SPEAK_TEXT };
  4875.  
  4876.     if(SpeechConfig . Enabled && English)
  4877.         Say(Args[ARG_SPEAK_TEXT]);
  4878.     else
  4879.         Results[0] = RC_WARN;
  4880.  
  4881.     return(NULL);
  4882. }
  4883.  
  4884. STRPTR
  4885. RexxStopBits(struct RexxPkt *Pkt)
  4886. {
  4887.     enum    {    ARG_STOPBITS_0,ARG_STOPBITS_1 };
  4888.  
  4889.     BYTE Bits;
  4890.  
  4891.     if(Args[ARG_STOPBITS_0])
  4892.         Bits = 0;
  4893.  
  4894.     if(Args[ARG_STOPBITS_1])
  4895.         Bits = 1;
  4896.  
  4897.     if(Config -> SerialConfig -> StopBits != Bits)
  4898.     {
  4899.         Config -> SerialConfig -> StopBits = Bits;
  4900.  
  4901.         UpdateRequired = TRUE;
  4902.  
  4903.         ConfigChanged = TRUE;
  4904.     }
  4905.  
  4906.     return(NULL);
  4907. }
  4908.  
  4909. STRPTR
  4910. RexxTextBuffer(struct RexxPkt *Pkt)
  4911. {
  4912.     enum    {    ARG_TEXTBUFFER_LOCK,ARG_TEXTBUFFER_UNLOCK };
  4913.  
  4914.     Forbid();
  4915.  
  4916.     if(Args[ARG_TEXTBUFFER_LOCK])
  4917.         BufferFrozen = TRUE;
  4918.  
  4919.     if(Args[ARG_TEXTBUFFER_UNLOCK])
  4920.         BufferFrozen = FALSE;
  4921.  
  4922.     CheckItem(MEN_FREEZE_BUFFER,BufferFrozen);
  4923.  
  4924.     ConOutputUpdate();
  4925.  
  4926.     Permit();
  4927.  
  4928.     return(NULL);
  4929. }
  4930.  
  4931. STRPTR
  4932. RexxTimeout(struct RexxPkt *Pkt)
  4933. {
  4934.     enum    {    ARG_TIMEOUT_SECONDS,ARG_TIMEOUT_OFF };
  4935.  
  4936.     if(Args[ARG_TIMEOUT_OFF])
  4937.         RexxTimeoutVal = 0;
  4938.     else
  4939.         RexxTimeoutVal = *(LONG *)Args[ARG_TIMEOUT_SECONDS];
  4940.  
  4941.     return(NULL);
  4942.  
  4943. }
  4944.  
  4945. STRPTR
  4946. RexxTrap(struct RexxPkt *Pkt)
  4947. {
  4948.     enum    {    ARG_TRAP_ON,ARG_TRAP_OFF };
  4949.  
  4950.     BOOLEAN Enabled;
  4951.  
  4952.     Forbid();
  4953.  
  4954.     if(Args[ARG_TRAP_ON])
  4955.         Enabled = TRUE;
  4956.  
  4957.     if(Args[ARG_TRAP_OFF])
  4958.         Enabled = FALSE;
  4959.  
  4960.     CheckItem(MEN_DISABLE_TRAPS,Enabled ^ TRUE);
  4961.  
  4962.     Permit();
  4963.  
  4964.     ObtainSemaphore(&GenericListTable[GLIST_TRAP] -> ListSemaphore);
  4965.  
  4966.     if(GenericListTable[GLIST_TRAP] -> ListHeader . mlh_Head -> mln_Succ && Enabled)
  4967.         WatchTraps = TRUE;
  4968.     else
  4969.         WatchTraps = FALSE;
  4970.  
  4971.     ReleaseSemaphore(&GenericListTable[GLIST_TRAP] -> ListSemaphore);
  4972.  
  4973.     return(NULL);
  4974. }
  4975.  
  4976. STATIC STRPTR         RexxWaitResult;
  4977. STATIC struct WaitNode    *RexxWaitNode;
  4978.  
  4979. STATIC BOOLEAN
  4980. RexxWaitBypass(STRPTR Buffer,LONG Size)
  4981. {
  4982.     LONG Position;
  4983.  
  4984.     RexxWaitResult = ScanNodeFilter(Buffer,Size,RexxWaitNode,&Position);
  4985.  
  4986.     SerWriteVerbatim(Buffer,Size,FALSE);
  4987.  
  4988.     return(FALSE);
  4989. }
  4990.  
  4991. STRPTR
  4992. RexxWait(struct RexxPkt *Pkt)
  4993. {
  4994.     enum    {    ARG_WAIT_NOECHO,ARG_WAIT_TEXT };
  4995.  
  4996.     ULONG         Signals;
  4997.     STRPTR         Result = NULL;
  4998.     BYTE         Echo;
  4999.     struct WaitNode    *WaitNode,
  5000.              Node;
  5001.     UBYTE         DummyBuffer[256];
  5002.     LONG         Position;
  5003.     struct List     DummyList;
  5004.  
  5005.     if(!ReadRequest || !WriteRequest)
  5006.     {
  5007.         Results[0] = RC_WARN;
  5008.  
  5009.         return(NULL);
  5010.     }
  5011.  
  5012.     if(Args[ARG_WAIT_NOECHO])
  5013.         Echo = FALSE;
  5014.     else
  5015.         Echo = TRUE;
  5016.  
  5017.     if(Args[ARG_WAIT_TEXT])
  5018.     {
  5019.         WORD i,Len;
  5020.  
  5021.         NewList(&DummyList);
  5022.  
  5023.         memcpy(DummyBuffer,Args[ARG_WAIT_TEXT],255);
  5024.  
  5025.         DummyBuffer[255] = 0;
  5026.  
  5027.         for(i = 0 ; i < strlen(DummyBuffer) ; i++)
  5028.             DummyBuffer[i] = ToUpper(DummyBuffer[i]);
  5029.  
  5030.         Len = TranslateString(DummyBuffer,DummyBuffer);
  5031.  
  5032.         DummyBuffer[Len] = 0;
  5033.  
  5034.         memset(&Node,0,sizeof(struct WaitNode));
  5035.  
  5036.         Node . Node . ln_Name    = DummyBuffer;
  5037.         Node . Count        = 0;
  5038.  
  5039.         WaitNode = &Node;
  5040.  
  5041.         AddTail(&DummyList,(struct Node *)WaitNode);
  5042.     }
  5043.     else
  5044.     {
  5045.         if(!GenericListCount(GenericListTable[GLIST_WAIT]))
  5046.         {
  5047.             Results[0] = RC_ERROR;
  5048.             Results[1] = TERMERROR_LIST_IS_ALREADY_EMPTY;
  5049.  
  5050.             return(NULL);
  5051.         }
  5052.         else
  5053.         {
  5054.             WaitNode = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  5055.  
  5056.             while(WaitNode -> Node . ln_Succ)
  5057.             {
  5058.                 WaitNode -> Count = 0;
  5059.  
  5060.                 WaitNode = (struct WaitNode *)WaitNode -> Node . ln_Succ;
  5061.             }
  5062.  
  5063.             WaitNode = NULL;
  5064.         }
  5065.     }
  5066.  
  5067.     if(RexxTimeoutVal)
  5068.         StartTime(RexxTimeoutVal,0);
  5069.  
  5070.     WaitCount = 0;
  5071.  
  5072.     BlockWindows();
  5073.  
  5074.     Forbid();
  5075.  
  5076.     LT_UnlockWindow(Window);
  5077.  
  5078.     Window -> Flags |= WFLG_RMBTRAP;
  5079.  
  5080.     Permit();
  5081.  
  5082.     if(Marking)
  5083.         DropMarker();
  5084.  
  5085.     NormalCursor();
  5086.  
  5087.     if(DataHold)
  5088.     {
  5089.         if(Echo)
  5090.         {
  5091.             ConProcess(DataHold,DataSize);
  5092.  
  5093.             Status = STATUS_READY;
  5094.         }
  5095.  
  5096.         if(Result = ScanNodeFilter(DataHold,DataSize,WaitNode,&Position))
  5097.         {
  5098.             if(Position < DataSize)
  5099.             {
  5100.                 DataHold += Position;
  5101.                 DataSize -= Position;
  5102.             }
  5103.             else
  5104.             {
  5105.                 DataHold = NULL;
  5106.  
  5107.                 RestartSerial(TRUE);
  5108.             }
  5109.         }
  5110.         else
  5111.         {
  5112.             DataHold = NULL;
  5113.  
  5114.             RestartSerial(TRUE);
  5115.         }
  5116.     }
  5117.  
  5118.     if(!Result)
  5119.     {
  5120.         if(CheckSerialRead())
  5121.             Signals = SIG_SERIAL;
  5122.         else
  5123.             Signals = NULL;
  5124.  
  5125.         do
  5126.         {
  5127.             if(Signals & SIG_WINDOW)
  5128.             {
  5129.                 if(!Result)
  5130.                 {
  5131.                     SerWriteBypass = RexxWaitBypass;
  5132.  
  5133.                     RexxWaitResult    = Result;
  5134.                     RexxWaitNode    = WaitNode;
  5135.  
  5136.                     while(HandleWindow());
  5137.  
  5138.                     Result = RexxWaitResult;
  5139.  
  5140.                     SerWriteBypass = NULL;
  5141.                 }
  5142.             }
  5143.  
  5144.             if(Signals & SIG_SERIAL)
  5145.             {
  5146.                 BOOLEAN Restart = TRUE;
  5147.  
  5148.                 if(!WaitSerialRead())
  5149.                 {
  5150.                     LONG Length;
  5151.  
  5152.                     BytesIn++;
  5153.  
  5154.                     if(Translate_CR_LF)
  5155.                         Length = (*Translate_CR_LF)(ReadBuffer,1);
  5156.                     else
  5157.                         Length = 1;
  5158.  
  5159.                     if(Echo && Length)
  5160.                     {
  5161.                         ConProcess(ReadBuffer,Length);
  5162.  
  5163.                         Status = STATUS_READY;
  5164.                     }
  5165.  
  5166.                     if(!Result && Length)
  5167.                         Result = ScanNodeFilter(ReadBuffer,Length,WaitNode,&Position);
  5168.  
  5169.                     if(!Result)
  5170.                     {
  5171.                             /* Check how many bytes are still in
  5172.                              * the serial buffer.
  5173.                              */
  5174.  
  5175.                         if(Length = GetSerialWaiting())
  5176.                         {
  5177.                             if(Length > SerialBufferSize)
  5178.                                 Length = SerialBufferSize;
  5179.  
  5180.                             if(Length > Config -> SerialConfig -> Quantum)
  5181.                                 Length = Config -> SerialConfig -> Quantum;
  5182.  
  5183.                             if(!DoSerialRead(ReadBuffer,Length))
  5184.                             {
  5185.                                 BytesIn += Length;
  5186.  
  5187.                                 if(Translate_CR_LF)
  5188.                                     Length = (* Translate_CR_LF)(ReadBuffer,Length);
  5189.  
  5190.                                 if(Length)
  5191.                                 {
  5192.                                         /* Send the data to the console. */
  5193.  
  5194.                                     if(Echo)
  5195.                                     {
  5196.                                         ConProcess(ReadBuffer,Length);
  5197.  
  5198.                                         Status = STATUS_READY;
  5199.                                     }
  5200.  
  5201.                                     if(Result = ScanNodeFilter(ReadBuffer,Length,WaitNode,&Position))
  5202.                                     {
  5203.                                         if(Position < Length)
  5204.                                         {
  5205.                                             DataHold = (UBYTE *)ReadBuffer    + Position;
  5206.                                             DataSize = Length        - Position;
  5207.  
  5208.                                             Restart = FALSE;
  5209.                                         }
  5210.                                         else
  5211.                                             DataHold = NULL;
  5212.                                     }
  5213.                                 }
  5214.                             }
  5215.                         }
  5216.                     }
  5217.                 }
  5218.  
  5219.                 if(Restart)
  5220.                     RestartSerial(TRUE);
  5221.             }
  5222.  
  5223.             if(Signals & (SIG_BREAK | SIG_TIMER))
  5224.             {
  5225.                 if(!Result)
  5226.                     Results[0] = RC_WARN;
  5227.  
  5228.                 break;
  5229.             }
  5230.  
  5231.             if(!Result)
  5232.                 Signals = Wait(SIG_SERIAL | SIG_TIMER | SIG_BREAK | SIG_WINDOW);
  5233.         }
  5234.         while(!Result);
  5235.     }
  5236.  
  5237.     Forbid();
  5238.  
  5239.     Window -> Flags &= ~WFLG_RMBTRAP;
  5240.  
  5241.     LT_LockWindow(Window);
  5242.  
  5243.     Permit();
  5244.  
  5245.     ReleaseWindows();
  5246.  
  5247.     if(RexxTimeoutVal)
  5248.         StopTime();
  5249.  
  5250.     if(Result)
  5251.         return(CreateResult(Result,Results));
  5252.     else
  5253.         return(NULL);
  5254. }
  5255.  
  5256. STRPTR
  5257. RexxWindow(struct RexxPkt *Pkt)
  5258. {
  5259.     enum    {    ARG_WINDOW_NAMES,ARG_WINDOW_OPEN,ARG_WINDOW_CLOSE,ARG_WINDOW_ACTIVATE,
  5260.             ARG_WINDOW_MIN,ARG_WINDOW_MAX,ARG_WINDOW_FRONT,ARG_WINDOW_BACK,
  5261.             ARG_WINDOW_TOP,ARG_WINDOW_BOTTOM,ARG_WINDOW_UP,ARG_WINDOW_DOWN };
  5262.  
  5263.     STRPTR    *Names = (STRPTR *)Args[ARG_WINDOW_NAMES];
  5264.     WORD     Index;
  5265.  
  5266.     while(*Names)
  5267.     {
  5268.         if((Index = ToWindow(*Names++)) != -1)
  5269.         {
  5270.             if(Args[ARG_WINDOW_OPEN])
  5271.             {
  5272.                 Forbid();
  5273.  
  5274.                 switch(Index)
  5275.                 {
  5276.                     case WINDOWID_BUFFER:
  5277.  
  5278.                         ObtainSemaphore(&BufferTaskSemaphore);
  5279.  
  5280.                         if(!BufferTask)
  5281.                         {
  5282.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5283.  
  5284.                             LaunchBuffer();
  5285.                         }
  5286.                         else
  5287.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5288.  
  5289.                         break;
  5290.  
  5291.                     case WINDOWID_UPLOAD_QUEUE:
  5292.  
  5293.                         CreateQueueProcess();
  5294.  
  5295.                         break;
  5296.  
  5297.                     case WINDOWID_REVIEW:
  5298.  
  5299.                         if(!ReviewWindow)
  5300.                             CreateReview();
  5301.  
  5302.                         break;
  5303.  
  5304.                     case WINDOWID_PACKET:
  5305.  
  5306.                         if(!PacketWindow)
  5307.                             CreatePacketWindow();
  5308.  
  5309.                         break;
  5310.  
  5311.                     case WINDOWID_FASTMACROS:
  5312.  
  5313.                         if(!FastWindow)
  5314.                             OpenFastWindow();
  5315.  
  5316.                         break;
  5317.  
  5318.                     case WINDOWID_STATUS:
  5319.  
  5320.                         if(!InfoWindow)
  5321.                             OpenInfoWindow();
  5322.  
  5323.                         break;
  5324.  
  5325.                     case WINDOWID_MAIN:
  5326.  
  5327.                         if(!IconTerminated)
  5328.                             IconTerminated = TRUE;
  5329.  
  5330.                         break;
  5331.                 }
  5332.  
  5333.                 Permit();
  5334.             }
  5335.  
  5336.             if(Args[ARG_WINDOW_CLOSE])
  5337.             {
  5338.                 Forbid();
  5339.  
  5340.                 switch(Index)
  5341.                 {
  5342.                     case WINDOWID_UPLOAD_QUEUE:
  5343.  
  5344.                         CloseQueueWindow();
  5345.                         break;
  5346.  
  5347.                     case WINDOWID_BUFFER:
  5348.  
  5349.                         ObtainSemaphore(&BufferTaskSemaphore);
  5350.  
  5351.                         if(BufferTask)
  5352.                         {
  5353.                             Signal(BufferTask,SIG_KILL);
  5354.  
  5355.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5356.  
  5357.                             ClrSignal(SIG_HANDSHAKE);
  5358.  
  5359.                             Wait(SIG_HANDSHAKE);
  5360.                         }
  5361.                         else
  5362.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5363.  
  5364.                         break;
  5365.  
  5366.                     case WINDOWID_REVIEW:
  5367.  
  5368.                         if(ReviewWindow)
  5369.                             DeleteReview();
  5370.  
  5371.                         break;
  5372.  
  5373.                     case WINDOWID_PACKET:
  5374.  
  5375.                         if(PacketWindow)
  5376.                             DeletePacketWindow(FALSE);
  5377.  
  5378.                         break;
  5379.  
  5380.                     case WINDOWID_FASTMACROS:
  5381.  
  5382.                         if(FastWindow)
  5383.                             CloseFastWindow();
  5384.  
  5385.                         break;
  5386.  
  5387.                     case WINDOWID_STATUS:
  5388.  
  5389.                         if(InfoWindow)
  5390.                             CloseInfoWindow();
  5391.  
  5392.                         break;
  5393.  
  5394.                     case WINDOWID_MAIN:
  5395.  
  5396.                         if(Window)
  5397.                             DoIconify = TRUE;
  5398.  
  5399.                         break;
  5400.                 }
  5401.  
  5402.                 Permit();
  5403.             }
  5404.  
  5405.             if(Args[ARG_WINDOW_ACTIVATE])
  5406.             {
  5407.                 Forbid();
  5408.  
  5409.                 switch(Index)
  5410.                 {
  5411.                     case WINDOWID_UPLOAD_QUEUE:
  5412.  
  5413.                         CreateQueueProcess();
  5414.  
  5415.                         break;
  5416.  
  5417.                     case WINDOWID_BUFFER:
  5418.  
  5419.                         ObtainSemaphore(&BufferTaskSemaphore);
  5420.  
  5421.                         if(BufferTask)
  5422.                         {
  5423.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5424.  
  5425.                             LaunchBuffer();
  5426.                         }
  5427.                         else
  5428.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5429.  
  5430.                         break;
  5431.  
  5432.                     case WINDOWID_REVIEW:
  5433.  
  5434.                         if(ReviewWindow)
  5435.                             BumpWindow(ReviewWindow);
  5436.  
  5437.                         break;
  5438.  
  5439.                     case WINDOWID_PACKET:
  5440.  
  5441.                         if(PacketWindow)
  5442.                             BumpWindow(PacketWindow);
  5443.  
  5444.                         break;
  5445.  
  5446.                     case WINDOWID_FASTMACROS:
  5447.  
  5448.                         if(FastWindow)
  5449.                             BumpWindow(FastWindow);
  5450.  
  5451.                         break;
  5452.  
  5453.                     case WINDOWID_STATUS:
  5454.  
  5455.                         if(InfoWindow)
  5456.                             BumpWindow(InfoWindow);
  5457.  
  5458.                         break;
  5459.  
  5460.                     case WINDOWID_MAIN:
  5461.  
  5462.                         if(Window)
  5463.                             BumpWindow(Window);
  5464.  
  5465.                         break;
  5466.                 }
  5467.  
  5468.                 Permit();
  5469.             }
  5470.  
  5471.             if(Args[ARG_WINDOW_MIN])
  5472.             {
  5473.                 struct Window *SomeWindow = NULL;
  5474.  
  5475.                 Forbid();
  5476.  
  5477.                 switch(Index)
  5478.                 {
  5479.                     case WINDOWID_REVIEW:
  5480.  
  5481.                         SomeWindow = ReviewWindow;
  5482.                         break;
  5483.  
  5484.                     case WINDOWID_PACKET:
  5485.  
  5486.                         SomeWindow = PacketWindow;
  5487.                         break;
  5488.  
  5489.                     case WINDOWID_FASTMACROS:
  5490.  
  5491.                         SomeWindow = FastWindow;
  5492.                         break;
  5493.  
  5494.                     case WINDOWID_STATUS:
  5495.  
  5496.                         SomeWindow = InfoWindow;
  5497.                         break;
  5498.                 }
  5499.  
  5500.                 if(SomeWindow)
  5501.                     ChangeWindowBox(SomeWindow,SomeWindow -> LeftEdge,SomeWindow -> TopEdge,SomeWindow -> MinWidth,SomeWindow -> MinHeight);
  5502.  
  5503.                 Permit();
  5504.             }
  5505.  
  5506.             if(Args[ARG_WINDOW_MAX])
  5507.             {
  5508.                 struct Window *SomeWindow = NULL;
  5509.  
  5510.                 Forbid();
  5511.  
  5512.                 switch(Index)
  5513.                 {
  5514.                     case WINDOWID_REVIEW:
  5515.  
  5516.                         SomeWindow = ReviewWindow;
  5517.                         break;
  5518.  
  5519.                     case WINDOWID_PACKET:
  5520.  
  5521.                         SomeWindow = PacketWindow;
  5522.                         break;
  5523.  
  5524.                     case WINDOWID_FASTMACROS:
  5525.  
  5526.                         SomeWindow = FastWindow;
  5527.                         break;
  5528.  
  5529.                     case WINDOWID_STATUS:
  5530.  
  5531.                         SomeWindow = InfoWindow;
  5532.                         break;
  5533.                 }
  5534.  
  5535.                 if(SomeWindow)
  5536.                     ChangeWindowBox(SomeWindow,0,0,SomeWindow -> MaxWidth,SomeWindow -> MaxHeight);
  5537.  
  5538.                 Permit();
  5539.             }
  5540.  
  5541.             if(Args[ARG_WINDOW_FRONT])
  5542.             {
  5543.                 Forbid();
  5544.  
  5545.                 switch(Index)
  5546.                 {
  5547.                     case WINDOWID_UPLOAD_QUEUE:
  5548.  
  5549.                         CreateQueueProcess();
  5550.  
  5551.                         break;
  5552.  
  5553.                     case WINDOWID_BUFFER:
  5554.  
  5555.                         ObtainSemaphore(&BufferTaskSemaphore);
  5556.  
  5557.                         if(BufferTask)
  5558.                         {
  5559.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5560.  
  5561.                             LaunchBuffer();
  5562.                         }
  5563.                         else
  5564.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5565.  
  5566.                         break;
  5567.  
  5568.                     case WINDOWID_REVIEW:
  5569.  
  5570.                         if(ReviewWindow)
  5571.                             WindowToFront(ReviewWindow);
  5572.  
  5573.                         break;
  5574.  
  5575.                     case WINDOWID_PACKET:
  5576.  
  5577.                         if(PacketWindow)
  5578.                             WindowToFront(PacketWindow);
  5579.  
  5580.                         break;
  5581.  
  5582.                     case WINDOWID_FASTMACROS:
  5583.  
  5584.                         if(FastWindow)
  5585.                             WindowToFront(FastWindow);
  5586.  
  5587.                         break;
  5588.  
  5589.                     case WINDOWID_STATUS:
  5590.  
  5591.                         if(InfoWindow)
  5592.                             WindowToFront(InfoWindow);
  5593.  
  5594.                         break;
  5595.  
  5596.                     case WINDOWID_MAIN:
  5597.  
  5598.                         if(Window)
  5599.                             WindowToFront(Window);
  5600.  
  5601.                         break;
  5602.                 }
  5603.  
  5604.                 Permit();
  5605.             }
  5606.  
  5607.             if(Args[ARG_WINDOW_BACK])
  5608.             {
  5609.                 Forbid();
  5610.  
  5611.                 switch(Index)
  5612.                 {
  5613.                     case WINDOWID_REVIEW:
  5614.  
  5615.                         if(ReviewWindow)
  5616.                             WindowToBack(ReviewWindow);
  5617.  
  5618.                         break;
  5619.  
  5620.                     case WINDOWID_PACKET:
  5621.  
  5622.                         if(PacketWindow)
  5623.                             WindowToBack(PacketWindow);
  5624.  
  5625.                         break;
  5626.  
  5627.                     case WINDOWID_FASTMACROS:
  5628.  
  5629.                         if(FastWindow)
  5630.                             WindowToBack(FastWindow);
  5631.  
  5632.                         break;
  5633.  
  5634.                     case WINDOWID_STATUS:
  5635.  
  5636.                         if(InfoWindow)
  5637.                             WindowToBack(InfoWindow);
  5638.  
  5639.                         break;
  5640.  
  5641.                     case WINDOWID_MAIN:
  5642.  
  5643.                         if(Window)
  5644.                             WindowToBack(Window);
  5645.  
  5646.                         break;
  5647.                 }
  5648.  
  5649.                 Permit();
  5650.             }
  5651.  
  5652.             Forbid();
  5653.  
  5654.             if(Index == WINDOW_REVIEW && ReviewWindow)
  5655.             {
  5656.                 if(Args[ARG_WINDOW_TOP])
  5657.                     MoveReview(REVIEW_MOVE_TOP);
  5658.  
  5659.                 if(Args[ARG_WINDOW_BOTTOM])
  5660.                     MoveReview(REVIEW_MOVE_BOTTOM);
  5661.  
  5662.                 if(Args[ARG_WINDOW_UP])
  5663.                     MoveReview(REVIEW_MOVE_UP);
  5664.  
  5665.                 if(Args[ARG_WINDOW_DOWN])
  5666.                     MoveReview(REVIEW_MOVE_DOWN);
  5667.             }
  5668.  
  5669.             Permit();
  5670.         }
  5671.     }
  5672.  
  5673.     return(NULL);
  5674. }
  5675.  
  5676. STRPTR
  5677. RexxRX(struct RexxPkt *Pkt)
  5678. {
  5679.     enum    {    ARG_RX_CONSOLE,ARG_RX_ASYNC,ARG_RX_COMMAND };
  5680.  
  5681.     struct MsgPort    *RexxPort;
  5682.     BYTE         Eaten = FALSE;
  5683.  
  5684.     if(RexxPort = FindPort(RXSDIR))
  5685.     {
  5686.         struct MsgPort __aligned     SinglePort;
  5687.         struct RexxMsg            *HostMessage;
  5688.  
  5689.         InitSinglePort(&SinglePort);
  5690.  
  5691.         if(HostMessage = CreateRexxMsg(&SinglePort,"term",RexxPortName))
  5692.         {
  5693.             if(HostMessage -> rm_Args[0] = CreateArgstring(Args[ARG_RX_COMMAND],strlen(Args[ARG_RX_COMMAND])))
  5694.             {
  5695.                 HostMessage -> rm_Action = RXCOMM;
  5696.  
  5697.                 if(!GoodStream(NULL))
  5698.                     HostMessage -> rm_Action |= RXFF_NOIO;
  5699.  
  5700.                 if(Args[ARG_RX_ASYNC])
  5701.                 {
  5702.                     RexxPktCleanup(Pkt,NULL);
  5703.  
  5704.                     Eaten = TRUE;
  5705.                 }
  5706.  
  5707.                 Forbid();
  5708.  
  5709.                 PutMsg(RexxPort,HostMessage);
  5710.  
  5711.                 ClrSignal(SIGF_SINGLE);
  5712.  
  5713.                 WaitPort(&SinglePort);
  5714.  
  5715.                 Permit();
  5716.  
  5717.                 GetMsg(&SinglePort);
  5718.  
  5719.                 if(!Eaten)
  5720.                 {
  5721.                     Results[0] = HostMessage -> rm_Result1;
  5722.                     Results[1] = HostMessage -> rm_Result2;
  5723.                 }
  5724.             }
  5725.             else
  5726.             {
  5727.                 Results[0] = RC_ERROR;
  5728.                 Results[1] = ERR10_003;
  5729.             }
  5730.  
  5731.             DeleteRexxMsg(HostMessage);
  5732.         }
  5733.         else
  5734.         {
  5735.             Results[0] = RC_ERROR;
  5736.             Results[1] = ERR10_003;
  5737.         }
  5738.     }
  5739.     else
  5740.     {
  5741.         Results[0] = RC_ERROR;
  5742.         Results[1] = ERR10_013;
  5743.     }
  5744.  
  5745.     if(!Eaten)
  5746.         RexxPktCleanup(Pkt,NULL);
  5747.  
  5748.     return(NULL);
  5749. }
  5750.  
  5751. STRPTR
  5752. RexxExecTool(struct RexxPkt *Pkt)
  5753. {
  5754.     enum    {    ARG_EXECTOOL_CONSOLE,ARG_EXECTOOL_ASYNC,ARG_EXECTOOL_PORT,ARG_EXECTOOL_COMMAND };
  5755.  
  5756.     LONG     Error;
  5757.     UBYTE     CommandName[256],
  5758.          CommandArgs[256],
  5759.         *Index = Args[ARG_EXECTOOL_COMMAND];
  5760.     WORD     i;
  5761.     BYTE     Eaten = FALSE;
  5762.  
  5763.     while(*Index == ' ' || *Index == '\t')
  5764.         Index++;
  5765.  
  5766.     for(i = 0 ; Index[i] != ' ' && Index[i] != '\t' ; i++)
  5767.         CommandName[i] = Index[i];
  5768.  
  5769.     CommandName[i] = 0;
  5770.  
  5771.     Index += i;
  5772.  
  5773.     while(*Index == ' ' || *Index == '\t')
  5774.         Index++;
  5775.  
  5776.     if(Args[ARG_EXECTOOL_PORT])
  5777.         SPrintf(CommandArgs,"%s %s\n",Index,RexxPortName);
  5778.     else
  5779.         SPrintf(CommandArgs,"%s\n",Index);
  5780.  
  5781.     if(Args[ARG_EXECTOOL_ASYNC])
  5782.     {
  5783.         RexxPktCleanup(Pkt,NULL);
  5784.  
  5785.         Eaten = TRUE;
  5786.     }
  5787.  
  5788.     Error = SystemTags(CommandName,
  5789.         NP_Arguments,    CommandArgs,
  5790.         SYS_UserShell,    TRUE,
  5791.     TAG_DONE);
  5792.  
  5793.     if(!Eaten)
  5794.     {
  5795.         if(Error)
  5796.         {
  5797.             Results[0] = RC_ERROR;
  5798.             Results[1] = Error;
  5799.         }
  5800.  
  5801.         RexxPktCleanup(Pkt,NULL);
  5802.     }
  5803.  
  5804.     return(NULL);
  5805. }
  5806.